Chaotic Bouncing

G14PJS

Mathematics 4th Year Project

Spring 2012/2013

School of Mathematical Sciences

University of Nottingham

Wil O C Ward

Supervisor: Dr Martin Kurth

Division: Applied

Project code: MK P1

Assessment type: I

May 2013

I have read and understood the School and University guidelines on plagiarism.

I confirm that this work is my own, apart from the acknowledged references.

Abstract

The system of an inelastic ball bouncing on a vibrating plate is one

that has been reviewed extensively. For a plate modelled with a simple

sinusoid, a bifurcation of flight times has been observed through varying

oscillation frequency. This has previously been shown to lend itself to

pseudo-chaotic behaviour. In this project, the model is replicated and

results reproduced. Further to this, an extension of plate vibration

is investigated looking at the summation of sinusoids to vary systems.

Bifurcation plots are generated and generated for certain examples,

including differentiable approximations of less smooth waves such as the

sawtooth functions. The system is extended to contain a ceiling function

that provides a spatial upper limit inhibits ball flight. Investigations

on this system include constant limits and vibrating ceilings, with a

3D bifurcation model created for the constant function. General scripts

have been created using MATLAB for both free and limited systems,

that take in any twice-differentiable oscillation function representing

the plate and, where necessary, a twice-differentiable ceiling function.

Contents

List of Figures i

1 Introduction 1

2 Bouncing Ball on a Simple Vibrating Plate 3

2.1 Basic System . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2.2 Modelling Bounces . . . . . . . . . . . . . . . . . . . . . . . . . . 5

2.3 Bifurcation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

2.4 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8

2.5 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Generalising the Bouncing Ball System 12

3.1 Modelling an Oscillation System . . . . . . . . . . . . . . . . . . . 12

3.2 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

3.3 Examples and Results . . . . . . . . . . . . . . . . . . . . . . . . 16

4 Extending the Model 23

4.1 Bounding Flight from Above . . . . . . . . . . . . . . . . . . . . . 23

4.2 Implementation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

4.3 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26

5 Conclusions 30

5.1 Further Work . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32

5.2 Limitations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

References 35

A Code Listing 36

List of Figures

1 Area plot of flight times T bounded by Γ1, shown in grey. This is

the area for which the highest possible flight time is T . . . . . . 7

2 Plot of oscillating plate function xp(t) = cos(ωt) (blue curve), with

inelastic bouncing ball position plotted as black solid curve. Take-

off points are identified by red open circles and landing points by

black crosses, the black dashed line bounds the ‘sticking region’.

ω = 6.2631 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Bounce flight times T plotted against Γ for plate xp(t) = cos(ωt)

(blue points) showing bifurcation branches, forbidden regions and

pseudo-chaotic system. Grey area shows region bounded by Γ1 and

black solid lines show fixed points at T = 2kπ, k ∈ N . . . . . . . 10

4 Zoom of bifurcation plot in Figure 3 to Γ ∈ [7.1, 7.45]. Grey region

shows forbidden zone . . . . . . . . . . . . . . . . . . . . . . . . . 11

5 Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.253378:

blue solid curve represents plate oscillation function; black solid

curve is ball bounces [leaving at points marked with red disks and

landing at black crosses]; dashed black line shows sticking region

bound . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

6 Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.15 . . 13

7 Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.20.

Comparing with Figure 6, which models Γ = 7.15, shows bifurcation

with the increased number of bounces at this point . . . . . . . . 13

8 Bounce model of plate vibration xp(t) = A(cos(ωt)+sin(2ωt)) with

Γ = 5.7 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

i

9 Bounce model of plate vibration xp(t) = A(cos(ωt)− sin(2ωt)) with

Γ = 2.3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

10 Bifurcation plot of plate function xp(t) = A(cos(ωt) + sin(2ωt)) for

flight times T at each Γ . . . . . . . . . . . . . . . . . . . . . . . 18

11 Bifurcation plot of plate function xp(t) = A(cos(ωt)− sin(2ωt)) for

flight times T at each Γ . . . . . . . . . . . . . . . . . . . . . . . 18

12 Bounce model of plate vibration xp(t) = A(cos(ωt) − sin(2ωt) +

sin(ωt2

)) with Γ = 5 . . . . . . . . . . . . . . . . . . . . . . . . . . 19

13 Bifurcation plot of plate function xp(t) = A(cos(ωt) − sin(2ωt) +

sin(ωt2

)) for flight times T at each Γ . . . . . . . . . . . . . . . . 19

14 Bounce model of triangle plate vibration with Γ = 9 . . . . . . . . 21

15 Bounce model of sawtooth plate vibration with Γ = 4.5 . . . . . . 21

16 Bifurcation plot of triangle plate function for flight times T at each Γ 22

17 Bifurcation plot of sawtooth approximation plate function for flight

times T at each Γ . . . . . . . . . . . . . . . . . . . . . . . . . . . 22

18 Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4

restricted by a constant ceiling xc(t) = 7.5 . . . . . . . . . . . . . 24

19 Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4

restricted by a constant ceiling xc(t) = 8.0 . . . . . . . . . . . . . 27

20 Four perspectives of the 3D bifurcation plot showing bounce system

of plate xp(t) = A cos(ωt) and ceiling xc(t) = B. For each Γ, K is

used in the range of Γ to the peak of first flight . . . . . . . . . . 28

21 Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4

restricted by an oscillating ceiling xc(t) = B cos(ϑt) with K = 2 . 29

22 Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4

restricted by an oscillating ceiling xc(t) = B sin(ϑt) with K = 2 . 30

ii

23 Bounce model of plate vibration xp(t) = A(sin(ωt) + sin(2ωt)) with

Γ = 5 restricted by an oscillating ceiling xc(t) = B(cos(ϑt)+sin(ϑt))

with K = 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

24 Zoom of triangle plate function (3.4) on time period between t = 0

and t = π2. The approximation of sum is limited at k = 10. The

lower plot shows the gradient of the curve showing fine oscillations

along the slope that cause small flights of the ball . . . . . . . . . 34

iii

1 Introduction

A dynamical system that can be considered chaotic is one that exhibits a behaviour

of disorder that is highly sensitive to the effects of initial conditions [1]. These small

differences break down the predictability of the system, despite any deterministic

nature it has. Chaos is present and observable in many natural phenomena,

for example in hydrodynamical flow patterns and weather systems [2]. The

analysis and modelling of such is used to explain behaviour and seek improved

predictability.

One system that is known to experience chaotic behaviour is that of a ball

bouncing on an oscillating plate [3]. The dimensionless system, with bouncing

modelled on a sinusoidal vibration, has been part of numerous studies [4, 5, 6].

Affecting the frequency of oscillation has effects on the flight time of the ball,

which provides a model of changing behaviour. It has been noted that bifurcation

is experienced, a term used to describe a sudden change to a system due to small

alterations to model parameters [7]. Bifurcation typically accompanies the onset

of chaos.

A simple example of this has been theoretically and numerically resolved,

looking at a ball bouncing on a simple plate vibration function of a single sine

curve [8]. This review found that bifurcation was present, causing a cascade in

terms of flight time. In a finite range of control parameters, an infinite number of

bifurcation cascades occur and a psuedochaotic behaviour is observed. The first

stage of this project is to review this system and create a model that repeats the

results found.

There have also been studies based on oscillations that extend the system from

theory and model ball bouncing in a physical system [5, 6]. These were reviewed

for their theoretical models, however a physical investigation will not be a focus

1

in this project.

The main aim of the project described in this report is to computationally

model a dimensionless bouncing ball on an oscillating plate. By adjusting control

parameters and running the system to calculate flight times of each bounce, the

goal is to model bifurcation and chaotic behaviour described in related literature.

Initially a model is created of the most simple vibrational plate, described by

Gilet et al. [8]. The results are replicated such that their findings are re-observed.

Following this simple model, using the theory behind the bouncing system,

an implementation that simulates some general plate function is produced. This

takes some oscillation function for the plate that is at least twice differentiable and

numerically solves the flight time for some finite period. Again, control parameters

are varied and relevant bifurcation plots are created for multiple example vibration

models.

The theoretical system is extended to contain an upper bound to limit ball

system. This is input as a function on time, and investigation has included both a

constant bound and an oscillating ceiling based on a similar model to the vibrating

plate. Simple examples of this have been presented but, due to the sheer number

of possible combinations available by this extended generalisation, the analysis is

in no way exhaustive.

The programs created as part of this project have shown that it is easy to model

the flight of a bouncing ball for some general twice differentiable oscillation. It

has also been possible to model non-sinusoidal functions such as the triangle wave

through finite representation of their Fourier series. This numerical approximation

does, however, provide some systematic errors in the resulting plots.

Furthermore, bifurcation diagrams for both similar oscillation and examples

of the general model indicate the unpredictable nature of bouncing models on

varying complexities of oscillation, and some interesting phenomena occur under

2

certain conditions in many examples.

The general structure of this dissertation is as follows. The first section

discusses the oscillation of a simple single cosine wave as the simple model and

discusses the dynamics leading to the flight of a ball. Much of the theory is

based on the review presented by Gilet et al. [8]. Comments on bifurcation and

the different states expected to be present in the model are described as well

as predicted limits to be experienced. Details of the MATLAB implementation

written for this system are presented, along with results produced for the model.

Following the simple model, discussions on a generalisation of the plate oscil-

lation implementation are given. An explanation of the program capabilities as

well as methods utilised are given, and a number of example functions and their

results are shown with corresponding plots for demonstration.

The extension of the system is discussed in section 4 discussing the implemen-

tation of and theory behind the ceiling model. A small number of examples are

provided, and for the simplest model a visualised 3D bifurcation plot is displayed

and discussed.

Finally, conclusions found during the study are presented, along with potential

methods to further the results, including ideas for additional analysis. The end

of this section discusses the limitations of the models and comments on the

compromise between accuracy and computational efficiency.

2 Bouncing Ball on a Simple Vibrating Plate

2.1 Basic System

The system of an inelastic ball in one dimension bouncing vertically on a place

can be described with a combination of two simple spatial functions on time t.

These functions represent the plate’s location xp(t), and the location of the ball

3

xb(t). For a stationary plate, the system would be such that xp(t) is defined as

some constant.

For this investigation, initially a vibrating plate with a simple oscillatory

function is reviewed. The plate function can be described by a simple cosine

function, with no assumption made of the total time in the system. The function

is defined:

xp(t) = A cos(ωt) (2.1)

In this equation, alongside the time parameter t, the variables A and ω can be used

to represent the amplitude and frequency respectively of the plate’s oscillation.

Assume that at time t = 0, the ball is at rest on the plate, and that the ball

exhibits complete inelasticity, i.e. it does not retain any kinetic energy when

bouncing. When the plate begins to move, the initial take-off for the ball when it

first leaves the plate will occur when its acceleration is greater than the pull of

gravity. Until this point, the ball position matches that of the plate.

x = −Aω2 cos(ωt) ≤ −g

⇒ Aω2

gcos(ωt) ≥ 1

Here, x is the acceleration experienced by the ball calculated as the second

derivative of position with respect to time, x = dx2

d2t, and g = 9.80665m/s2 is

standard acceleration due to gravity.

From this, a parameter Γ can be defined as Γ = Aω2

g≥ 1. This represents

the reduced acceleration of the ball. Furthermore, the phase of plate oscillation

can be described by ϕ = ωt, where ϕ = ϕ0 at the point when the ball takes off

from the plate. When the ball leaves the plate, its relative position to the plate is

xb(ϕ) = xω2/g, where x(t) is the true spatial position of the ball at time t relative

4

to the origin. Thus,

xb(ϕ) = Γ(cos(ϕ0)− cos(ϕ))︸ ︷︷ ︸Location of plate after takeoff

+ Γ sinϕ0(ϕ0 − ϕ)− (ϕ0 − ϕ)2

2︸ ︷︷ ︸Displacement

(2.2)

Displacement, s, was calculated using the fact that s = ut+ 12at2, where u = x =

−Aω sinϕ0 is the velocity when leaving the place. In this system, t = ϕ− ϕ0 is

the flight time at ϕ, and acceleration acting on the ball is due to gravity, such

that a = −g. The system is divided through by g.

2.2 Modelling Bounces

Impact between the plate and the ball occurs when xb(ϕ) = 0. Suppose these

impacts occur at positions ϕ = ϕi, when the flight time is given by T = ϕi − ϕ0.

By this, it follows that:

xb(ϕi) = xb(ϕ0 + T )

= Γ[cosϕ0 − cos(ϕ0 + T )] + Γ sinϕ0(ϕ0 − ϕ0 − T ) +(ϕ0 − ϕ0 − T )2

2

= Γ[cosϕ0 − cosϕ0 cosT + sinϕ0 sinT ]− Γ sinϕ0 · T −T 2

2

= Γ cosϕ0(1− cosT )− Γ sinϕ0(T − sinT )− T 2

2

Consider the above equation that satisfies F ≡ xb(ϕi) = 0, then F can be solved

numerically for flight time, T .

The initial take-off occurs the first time normal force exerted by the plate

is directed upwards when the ball is resting on the plate. This is such that

Γ cosϕ0 ≤ 1, and means that trajectories begin at the first phase ϕ0 for which

Γ cosϕ0 = 1 (2.3)

Γ sinϕ0 = −√

Γ2 − 1 (2.4)

5

The ball may then impact in the region where Γ cosϕ > 1 and immediately bounce

again, as acceleration of the plate exceeds that due to gravity on the ball. If

the ball lands otherwise, it will stick to the plate until the system reaches the

Γ cosϕ0 > 1 condition and takes off again. This region, where the ball will not

bounce, is called the sticking region. It also has the property of ‘resetting’ the

bouncing ball system, meaning that when the ball takes off again, it does so with

the same properties as the initial bounce. The simulation follows the same pattern

of the first flight and the system begins again. This generates periodicity to the

bounces. A bouncing ball model that has n independent bounces before ‘resetting’

is called a period-n motion.

2.3 Bifurcation

The first flight time, T for each system satisfies the equation By substituting

conditions (2.3) and (2.4) for the bounce of the first flight into xb(ϕ1) it follows

that

xb(ϕ1) = 1− cosT +√

Γ2 − 1(T − sinT )− T 2

2= 0

Rearranging this for Γ, an initial flight time T for each system satisfies the equation

Γ = Γ1(T ) ≡

√√√√1 +

(T 2

2− 1 + cosT

T − sinT

)2

(2.5)

This shows that when the ball takes off with maximum velocity, T is the highest

possible flight time as solved by Gilet et al. The function is monotonically

increasing so Γ1(T ) is the smallest value of Γ that flight time T is observed. The

area bounded by Γ1(T ) is shown as the grey area in Figure 1.

Running the model over increasing values of ω and identifying flight times, T ,

for individual bounces within each system yields a plot bounded by Γ1(T ). The

plot shows that at certain values of Γ there is bifurcation occurring.

6

Bifurcation is the term given to sudden changes in the behaviour in a system

when a small parameter change is made. Such an event occurring locally typically

affects the stability of equilibrium in the system. In the case of this bouncing

ball system, bifurcation is present at values of Γ such that T = 2kπ, k ∈ N. The

system stably bounces for a short range of Γ, before bounces diverge into two

distinct pairs representing a period-2 motion. As Γ increases, the flight time for

the second bounce tends to T = 0, at which point the model returns to period-1

motion.

Gilet et al. asserts that there are three kinds of zones in the system, represented

by functions [8]. They are the bouncing, sticking and forbidden regions, delimited

by curves ΓBS(T ) and and ΓFB, where the subscript of a Γ function represents

the two zones it bounds, e.g. BS is between bouncing and sticking regions, and

Figure 1: Area plot of flight times T bounded by Γ1, shown in grey. This is the

area for which the highest possible flight time is T

7

FB is between forbidden and sticking regions. The functions are defined as

ΓBS(T ) =

(1 + T 2

2

)2− 2

(1 + T 2

2

)(T sinT + cosT ) + T 2 − 1

(sinT − T cosT )2(2.6)

ΓFB(T ) =T

2∣∣sin2 T

2

∣∣ (2.7)

2.4 Implementation

The initial implementation of the system involved reproducing the results from

the paper by Gilet et al. [8]. First, a plot representing a period-2 bounce model

was created. This was done using parameters A = 1 and ω = 6.2631, meaning

Γ = Aω2

g= 4.

The MATLAB script for this model first set up symbolic functions using the

Symbolic Mathematics Toolbox [9]. Functions representing the ball position, plate

position and plate acceleration were created as handles that could be evaluated

on parameters A and ϕ. A set of flight take-off points were calculated based on

the values of ϕ where conditions (2.3) and (2.4) were met. The lowest positive

value of this set was taken to be ϕ0 and the flight model begins from here.

After the setup of appropriate data structures to contain bounce information,

a loop incrementing the time parameter was run. Inside the loop, the script

measures the position of the ball against the position of the plate to detect a

bounce. Where one occurs, i.e. the xb function evaluated at the current time is

less than or equal to the plate xp, the current time was stored as the length of a

bounce.

Position of the bounce is accounted for and where a ball is contained in the

‘sticking’ region, the system is deemed to be complete. To accommodate stable

systems that will not get reset, an upper bound for number of bounces is included

such that once reached the model will end.

An optional figure of the model, such as the one seen in Figure 2, is plotted at

8

the end to show bounces and time. The function returns the array of flight times

experienced by the ball.

2.5 Results

The plot in Figure 2 shows the plot of bouncing such that Γ = 4. This was

the first model presented in Gilet et al. and was reproduced from this project

implementation. It clearly shows a period-2 bounce, such that it there are two

distinct bounces by the ball before it lands below the bounce zone. The system

then repeats itself.

Running this system over a wide range of control parameter Γ, a bifurcation

plot can be created by plotting the all flight times of bounces for each value of Γ.

Theoretically, the plot should be bounded by the Γ1 area, and as seen in Figure 3

Figure 2: Plot of oscillating plate function xp(t) = cos(ωt) (blue curve), with

inelastic bouncing ball position plotted as black solid curve. Take-off points are

identified by red open circles and landing points by black crosses, the black dashed

line bounds the ‘sticking region’. ω = 6.2631

9

this is limit observed by the model.

Regarding the bifurcation model for the plate function A cos(ϕ), from the plot

branches tending to zero can be seen, splitting from Γ values at T = 2kπ, k ∈ N.

It can be seen on the figure that there exists a forbidden region – this is most

notably observed around Γ = 7.1 where a break in the branch occurs. The curve

observes additional breaks, at Γ = 4.6 and Γ = 7.8

The plot in Figure 4 shows an increased detail of the Γ/T plot, zoomed in

between Γ = 7.10 and Γ = 7.45. This shows additional bifurcation branches

occurring such that there are infinite cascades of bounce times. This behaviour is

considered pseudo-chaotic rather than strictly chaotic because, while infinitely

branching, the system is logarithmically self similar in this data range, as shown

analytically by Gilet et al. [8].

Figure 3: Bounce flight times T plotted against Γ for plate xp(t) = cos(ωt) (blue

points) showing bifurcation branches, forbidden regions and pseudo-chaotic system.

Grey area shows region bounded by Γ1 and black solid lines show fixed points at

T = 2kπ, k ∈ N

10

Figure 4: Zoom of bifurcation plot in Figure 3 to Γ ∈ [7.1, 7.45]. Grey region

shows forbidden zone

Some examples of bounce plots for various values of Γ are shown to highlight

different levels of stability in bounces. In the next section, the model will be

generalised for any plate oscillations and systems will be visualised for a selection

of xp functions, in a similar fashion to this section.

An example of unstable bouncing can be seen in Figure 5 showing the ball

bouncing unstably near the peaks of plate oscillation. This is representative of

some of the infinite branches seen in Figure 4, and highlight bifurcation that

occurs where small changes of the bounce location cause big effects on flight times.

11

3 Generalising the Bouncing Ball System

3.1 Modelling an Oscillation System

In extending the model for a general vibration acting on the plate, it is necessary

to generalise the theory behind oscillation. This was largely addressed in the

justification of the basic model in section 2. For some plate vibration function

xp(t) containing parameters corresponding to amplitude A and frequency ω, the

acceleration is modelled by xp =dx2pd2t

. Using this, and the acceleration due to

gravity, the sticking region boundary and ball flight function can be calculated.

The former involves dividing through by gravity constant and such that a constant

inequality is created, thereby also calculating reduced acceleration Γ.

A model for the ball flight involves using plate location, done by calculating

Figure 5: Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.253378:

blue solid curve represents plate oscillation function; black solid curve is ball

bounces [leaving at points marked with red disks and landing at black crosses];

dashed black line shows sticking region bound

12

Figure 6: Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.15

Figure 7: Bounce model of plate vibration xp(t) = cos(ωt) with Γ = 7.20.

Comparing with Figure 6, which models Γ = 7.15, shows bifurcation with the

increased number of bounces at this point

13

displacement at phase ϕ and replacing ωt and ωt0 with ϕ and ϕ0 respectively,

where t0 is the time at which the ball leaves the plate.

xb(t) = Γ(xp(t0)− xp(t)) + xp(t0)(t− t0)−(t− t0)2

2(3.1)

Suppose a flight time is recorded as ϕi, with i corresponding to the current number

of bounces. Calculating xb(ϕi) = xb(ϕ0 + T ) can be done numerically by marking

the points at which ball function and plate function are crossed. Implementation

details follow, describing the creation of a generalised script using these properties

to run general plate functions.

3.2 Implementation

For a general bouncing system script, the Symbolic Toolbox of MATLAB was again

utilised. The main function script takes in a function handle representing plate

position, the corresponding amplitude and phase (frequency × time) parameters

of the function and an optional flag on whether to display the model.

Function handles in MATLAB begin with the @ symbol, and for a single

variable are simply a name to the function, e.g. @cos or @sin. However when

it is required, such as when the function is called on multiple variables, or is a

sum of multiple functions, there is a method for parametrising the handle. This

is done by declaring the function variables in the handle and then treating the

rest like a normal function call. An example, specifically the plate function from

section 2.1, can be seen as follows: h = @(A,p) A*cos(p). When evaluated,

it takes two variables as input and is equivalent to h(A,ϕ) = A cosϕ, e.g.

>> h(4,0.6675)

ans =

3.1415

14

Using these function handles, and the symvar, sym, and diff functions from

the Symbolic Toolbox, it is possible to calculate the ball function and simulate a

bouncing model for some input plate oscillation. Converting a MATLAB function

handle is possible by applying sym to it, which returns a ‘symbolic’ function.

This can be analytically differentiated by passing through diff. This function

takes the symbolic function and a symbolic variable for which to differentiate with

respect to. symvar is a means to obtain the variables of the symbolic function,

so one can be isolated. An example of finding plate velocity follows:

>> plate_func = @(A,p) A*cos(p);

>> func_var = symvar(sym(plate_func))

func_var =

[ A, p]

>> matlabFunction(-diff(sym(plate_func),func_var(2)))

ans =

@(A,p)A.*sin(p)

The inbuilt matlabFunction is the inverse operation to sym, returning a

function handle when given a symbolic function. These operations are similarly

used in calculating the ball position after take-off.

The take-off positions are identified by looking at the gradient of plate accel-

eration to measure the rate of change. Peak changes in plate acceleration were

isolated and positive change was taken to imply a departure point for the ball

resting on the plate.

Following this, the model creation works as in the simple case. Numerical

checks identify bounces, and the time variable is incremented until the system

resolves or an upper limit is reached. An optional figure is displayed, and the

length of flight at each bounce is returned by the function.

15

3.3 Examples and Results

Other potential functions to investigate involve summation of sinusoids. This gives

additional complexity to the vibrational oscillation of the plate, and bifurcations

will show the measure of stability on such systems.

Two plates measured involve the superposition of sine functions. These are

run through the model as handles. The following oscillations are investigated:

xp(ϕ) = Γ(cosϕ± sin(cϕ)) (3.2)

xp(ϕ) = Γ(cosϕ± sin(cϕ)± sin(ϕc

)) (3.3)

Some corresponding MATLAB function handles are:

xp = @(A,p) A*(cos(p) + sin(c*p));

xp = @(A,p) A*(cos(p) - sin(c*p));

xp = @(A,p) A*(cos(p) - sin(c*p) + sin((1/c)*p));

Additionally, different functions are considered. The triangle and sawtooth waves

as vibrations can be modelled if represented by a differentiable function. This can

be done by approximating their model with a Fourier series, seen here for triangle

and sawtooth functions respectively.

xp(ϕ) =8Γ

π2

∞∑k=0

(−1)ksin((2k + 1)ϕ)

(2k + 1)2(3.4)

xp(ϕ) =2Γ

π

∞∑k=1

(−1)k+1 sin(2πkϕ)

k(3.5)

Figures 8 and 9 show example bouncing plots for plate oscillation functions (3.2)

where c = 2. The first shows vibration with superposition of a positive sine wave,

the second a negative. In both cases there are two distinct peaks of the plate and

so acceleration needed for take-off occurs in two places in a single wave period.

Running these models across a range of values for Γ, as was done in section 2.

The resulting bifurcations plots can be seen respectively in Figures 10 and 11.

16

Figure 8: Bounce model of plate vibration xp(t) = A(cos(ωt) + sin(2ωt)) with

Γ = 5.7

Figure 9: Bounce model of plate vibration xp(t) = A(cos(ωt) − sin(2ωt)) with

Γ = 2.3

17

Figure 10: Bifurcation plot of plate function xp(t) = A(cos(ωt) + sin(2ωt)) for

flight times T at each Γ

Figure 11: Bifurcation plot of plate function xp(t) = A(cos(ωt) − sin(2ωt)) for

flight times T at each Γ

18

Figure 12: Bounce model of plate vibration xp(t) = A(cos(ωt)−sin(2ωt)+sin(ωt2

))

with Γ = 5

Figure 13: Bifurcation plot of plate function xp(t) = A(cos(ωt)−sin(2ωt)+sin(ωt2

))

for flight times T at each Γ

19

In both cases, these plots show two distinct branches that form the main graph

structure. In the case of xp(t) = A(cos(ωt) + sin(2ωt)), the upper limit branch

alternate and overlap, giving a single high flight time for approximately half of

the values of Γ and the rest overlapped. There is also the existence of multiple

sub-branches bifurcating and tending to zero. A potential forbidden region can

be seen around T = 5 from approximately Γ = 4 and above. However this was

not analytically identified. Alternatively, in the second bifurcation model, the

branches are more distinct with the upper limit more closely resembling that of

the basic plate oscillation bifurcation. There are many zero tending branches, and

a second branch caused by stable bouncing, increasing at a slower rate than the

upper limit branch. Psuedo-chaotic regions seem to be present at many of the

more vertical branches.

Adding an additional sine function to the plate equation, such as for (3.3),

results in a bounce model like the one seen in Figure 12. Here there is an additional

acceleration peak, as commented on above, and results in the bifurcation plot

shown in Figure 13. Here distinct monotonically increasing branches can be seen

for the respective sinusoidal components of the plate equation. Further branches

and unstable bounces can be seen in frequent intervals. This function does not

contain the overlapping branches seen in Figure 10, despite the vibration function

being a combination of the two. Clear stable regions are identified around Γ = 4.5

and Γ = 9, where the model is a period-1 system. It is likely that the bounces

at these frequencies fall directly into the sticking region of the corresponding

peak that they took off from. Furthermore, zero-tending bifurcation branches are

present in abundance in this graph, especially from the lowest branch associated

with the smallest frequency sine of the plate.

Using the approximations of non-sinusoidal waves, i.e. the triangle and saw-

tooth functions, results in small bounces occurring along the increasing curve due

20

Figure 14: Bounce model of triangle plate vibration with Γ = 9

Figure 15: Bounce model of sawtooth plate vibration with Γ = 4.5

21

Figure 16: Bifurcation plot of triangle plate function for flight times T at each Γ

Figure 17: Bifurcation plot of sawtooth approximation plate function for flight

times T at each Γ

22

to small ‘bumps’ in the function due to the summation of sines. As would be

expected with a constant upward acceleration, the ball leaves the plate only at

the peak of the plate’s oscillation. The sawtooth represents a purely theoretical

vibration, since there would be no time interval between the peak of a wave period

and the beginning of the next. Bounce functions on both plate models can be

seen, along with bifurcation plots [Figures 14, 15, 16 and 17].

4 Extending the Model

4.1 Bounding Flight from Above

Further work into extending on this investigation includes adding an upper bound

through which the ball cannot pass. This will provide an additional effect on the

stability of the system by limiting natural ball flight. Lines of inquiry include

using a constant position as the ceiling and also adding a further vibrating plate

such that the ball is bouncing between two similar oscillations but only affected

by gravity in a single direction.

The simplest implementation of an upper bound is simply to add a constant

limit at some point that lies always above the plate. When the ball leaves the

plate, if the bound is sufficiently low enough, it may collide with the ceiling of the

model. This sets the ball’s flight velocity to zero and thus any upward acceleration

it was experiencing is removed. The only force acting upon the ball is now the

acceleration due to gravity, and as such it begins to fall. This prematurely ends

the ball’s flight and could greatly affect stability of the system.

Extending this upper boundary to exhibit vibration similar to those modelled

on the lower plate presents additional cause for disorder in the system. Here,

where the ceiling’s downward acceleration is greater than that of gravity, the ball

will be pushed down until the force of the ceiling cannot act upon it.

23

Figure 18: Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4 restricted

by a constant ceiling xc(t) = 7.5

4.2 Implementation

The basis of this system is similar to that previously described. The main script

is adapted to accept an additional function and its respective parameters. The

ball flight is then handled for the points in which it collides with the ceiling.

If the natural flight of the ball collides with the plate its upwards velocity is set

to zero. In the case of the constant ceiling function, the ball then falls naturally

from a velocity of zero, affected solely by gravity. This is equivalent to if the peak

of natural flight had been reached at the point of collision.

For some oscillating plate, the system has more affect on flight. Here, the

24

downward velocity of the plate will push the ball and as such its downward flight

will begin with the velocity of the ceiling. The ball will only drop from the ceiling

when downward acceleration due is less than that of gravity. This is similar to

the requirements needed for initial take-off by the plate. For example, the simple

oscillating ceiling function xc(t) = B sin(ϑt) will accelerate the ball based on the

following condition

x = −Bϑ2 sin(ϑt) ≥ −g

⇒ Bϑ2

gsin(ϑt) ≤ 1

Based on this, a parameter reduced acceleration of the ceiling can be defined:

K = Bϑ2

g≥ 1. Parameters B and ϑ represent the respective amplitude and

frequency of the ceiling function and are independent of corresponding plate

parameters A and ω.

At the point of this condition holding, the ball drops from the ceiling. The

dropping trajectory is calculated in a similar way to the original flight function,

and as the ball drops, xb(t) = xd(t)

xd(t) = K(xc(tu)− xc(t))− xc(tu)(t− tu)−(t− tu)2

2(4.1)

The value tu marks the time at which the ball leaves the upper bounding ceiling.

For some constant bound xc(t) = B, frequency can be considered ϑ = 1 and so

K = B/g. The drop function still holds as a function containing the initial position

and the time due to gravity acceleration sections. This is due to xc = 0, since

xc is constant. However in the generalised extended MATLAB implementation,

special consideration for constant ceilings due to limitations of handling variables

in the Symbolic Toolbox.

The script itself differs from the single plate implementation only in the

inclusion of a drop function. During the position checks found in the main

25

modelling loop, a condition on whether the flight of the ball has exceeded the

bounds enforced by the ceiling. If this is the case, the position at which the ball

meets the ceiling is recorded and flight based on the acceleration of the flight is

calculated. In the event of a high acceleration downward movement by the ceiling,

the ball’s flight would pass above the plate in the next time steps and thus is

still considered to be at the upper limit. This continues until the effect of gravity

supersedes that caused by the ceiling, and the ball function drops. This point is

also recorded for plotting.

All other flights occur naturally and so if the path for a specific bounce falls

entirely below the upper bound, its flight time would be the same as were there

no ceiling. The outputs of the function are an optional figure and a data structure

containing bounce times in the same manner as the original script.

4.3 Results

Initially, the extension was tested on the simple plate detailed in section 2. A flat

ceiling placed at some point above the highest peak was modelled. Figures 18

and Figures 19 show the effects of ceiling height on the system plate. For this

system, a 3-dimensional bifurcation plot was created. The array of values for Γ is

used as with other bifurcation models, however the additional dimension comes

from values of K – the height of the ceiling. This was calculated to run from the

peak of the plate to the peak of the first flight. The diagram showing multiple

viewpoints can be seen in Figure 20.

It can be seen from the 3D bifurcation model that the general shape of the

bound enforced Γ1 is observed. However, there appear to be fewer bifurcation

branches in this dimension, compared with Figure 3. This implies that the system

with an upper bound exhibits more stability through varied values of Γ.

In contrast, when looking at the K/T perspective, multiple birfurcation

26

Figure 19: Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4 restricted

by a constant ceiling xc(t) = 8.0

branches can be seen. Here, the change in limit affects the stability of a system

more than the change in plate oscillation. It can be taken from the plots that

there are total forbidden regions of T occurring around the areas described in

equation (2.7).

The next stage of investigation involved the observing the ball bouncing

between two sine curves, using the simple oscillation model for both the upper and

lower boundary. In such a system, there are multiple parameters for consideration.

These include independent frequencies ω and ϕ, and corresponding reduced

acceleration Γ and K. In addition to this, there is the offset between points of

27

Fig

ure

20:

Fou

rp

ersp

ecti

ves

ofth

e3D

bif

urc

atio

nplo

tsh

owin

gb

ounce

syst

emof

pla

texp(t

)=A

cos(ωt)

and

ceilin

g

xc(t

)=B

.F

orea

chΓ

,K

isuse

din

the

range

ofΓ

toth

ep

eak

offi

rst

flig

ht

28

vibration and the height of the ceiling.

Figures 21 and 22 show the simple plate system bounded by a similarly

vibrating plate. When the ceiling oscillates at different frequency it is very

difficult to predict bounces and on a short time period there is no ‘resetting’

ability exhibited in the system.

The only difference between the two models are the offset of the ceiling –

Figure 21 shows a ceiling with B cos(ϑt), and Figure 22 is translated such that

xc(t) = B cos(ϑt− π2). The impact of this translation on the bounce model can

be seen and the flights experienced by the ball appear to be different. However,

in Figure 22 the bounce beginning ϕi = 49.62 meets the plate at a similar

position as flight at ϕi = 12.02 in Figure 21. The flights and bounds from these

respective points follow a similar pattern, suggesting this −π/2 translation of

the plate forward shifts the time parameter t by 3π. This may be due to the

similarities in oscillations, both between the two ceiling function and the with

Figure 21: Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4 restricted

by an oscillating ceiling xc(t) = B cos(ϑt) with K = 2

29

Figure 22: Bounce model of plate vibration xp(t) = A cos(ωt) with Γ = 4 restricted

by an oscillating ceiling xc(t) = B sin(ϑt) with K = 2

reduced acceleration K being a factor of the plate’s, Γ.

5 Conclusions

The aim outlined for this project was to replicate the results presented in the

paper by Gilet et al. [8], implementing a means to numerically solve the inelastic

bouncing ball problem in one dimension. Using a simple sinusoidal function to

represent a vibrating plate, the flight was modelled for increasing frequencies of

oscillation. The analytic bounds presented by Gilet et al. were modelled, and a

bifurcation matching that presented in the paper was generated.

A generalisation of this bouncing ball system was addressed to numerically

solve for any combination of sinusoidal oscillations. The requirement of the

plate function was that it is fully differentiable, and as such it is possible to

30

Figure 23: Bounce model of plate vibration xp(t) = A(sin(ωt) + sin(2ωt)) with

Γ = 5 restricted by an oscillating ceiling xc(t) = B(cos(ϑt) + sin(ϑt)) with K = 1

model velocity and acceleration. Thereby, the ball’s flight from the point it

leaves the plate to when it lands can successfully be calculated. Generalisation

implementation was successful in that for some two parameter MATLAB function

handle that is twice continuously differentiable, a plate function is modelled along

with successful bouncing functions. The bifurcations of example models were

analysed showing that sudden changes occur in multiple systems despite only

minor changes and that this oscillating system results in pseudo-chaotic behaviour

under certain conditions.

Additionally, the vibrational plate model was extended to investigate the

effects of an impassible upper bound. On the simple vibrating plate, both a

constant ceiling and oscillating models were investigated and the existence of an

upper bound was was found have additional effect on the stability. Moreover, a

bifurcation model was created in the case of the ‘flat’ ceiling, with independent

31

variables Γ and ceiling height adjusted. This created a 3D model and showed

that a ceiling limited the bifurcation experienced by varied Γ, but itself caused

instability based on the height.

Models were created containing simple oscillations of single sinusoidal waves,

but the effects of translating the oscillation in the time parameter, rather than

x, were reviewed. A factor of frequency was used to translate and this greatly

changed the bounce times. It was found that eventually the plate and ceiling

would sync up to the beginning of a translated model. This could only be due to

the fact that ceiling oscillation is exactly half that of the plate’s in the reviewed

model. Further investigation is possible, as discussed below.

Due to the generality of the implementation script, it is possible to test any

combination of differentiable oscillations, so long as the ceiling and plate do not

intersect (there is no handle for this as it assumed physically impossible - however

if the case arises, the ball will not bounce past the intersection). Because of this,

and the time limitations of the project there was no analysis on this. An example

of a potentially more complex system can be seen in Figure 23. It was created

using the following function call:

bounce_ceiling(@(A,p) A*(sin(p) + sin(2*p)),...

@(A,p) A*(cos(p)+sin(2*p))+15,...

sqrt(g*5),sqrt(g*1),1);

5.1 Further Work

Based on the extension of adding an upper bound through which the ball cannot

pass, there are many possible routes for further work. Any number of plate and

ceiling vibration combinations can be investigated, and different parameters on

these include height, frequency and translation. Each of the systems could be

32

modelled to investigation potential bifurcation by creating appropriate models.

The chaotic nature of such systems could be investigated and perhaps a measure

of the effects of similarity between dual plate oscillations identified.

While all investigations have involved the ball containing no elastic properties,

thereby not naturally bouncing from the plate due to reserved kinetic energy, this

is a possible inclusion. Varying elasticity of the ball could significantly change the

flight models when coupled with plate vibration, and as such could be closer to a

truly chaotic system: small changes in either elastic properties or vibration could

have larger impacts than in the case of an inelastic ball. Similarly, combining

this investigation with the idea of a upper bound plate could present an extensive

multivariate model.

As mentioned previously, and noted in the Gilet paper, some logarithmic

self similarity is present in the bifurcation plots. This similarity and potential

fractal properties could be an additional direction of investigation. Known chaotic

structures, such as attractors, have been analysed and found to be fractals [10].

Using this theory, it may be possible to quantify bifurcation and found in the

various bouncing models investigated in this project, both general and bounded.

5.2 Limitations

There exist some limitations in the general model. The simplest is that caused

by resolution of the discrete time approximation, with time interval used in the

project being set to 0.001. Another issue lies with the fact that the infinite

sums that form both the triangle and sawtooth functions need to be finitely

approximated. The number of summed sinusoids in the triangle wave is k = 10,

and for sawtooth k = 25. This formed a compromise between computational

runtime and smoothness of the curve.

Due to the limit of smoothness in the two Fourier series curves, there are the

33

Figure 24: Zoom of triangle plate function (3.4) on time period between t = 0

and t = π2. The approximation of sum is limited at k = 10. The lower plot shows

the gradient of the curve showing fine oscillations along the slope that cause small

flights of the ball

existence of small bumps in the straight line approximations. This means that

along the curve the ball experiences small flights as a form of turbulence caused

by the differentiable finite approximation of the curve. Figure 24 highlights the

existence of these bumps that are due to the limit on the infinite sum. The short

flights can also be seen in Figure 14 represented by red circles that occur frequently

along the increasing plate. The presence of these bumps may also cause premature

ball departure and contribute to bifurcation where it may not be present in a

truly flat plate velocity. The same could be said for the sawtooth representation.

34

References

[1] E. N. Lorenz, The essence of chaos. Routledge, 1995.

[2] E. N. Lorenz, “Deterministic nonperiodic flow,” Journal of the atmospheric

sciences, vol. 20, no. 2, pp. 130–141, 1963.

[3] T. Kruger, L. Pustyl’nikov, and S. Troubetzkoy, “Acceleration of bouncing

balls in external fields,” Nonlinearity, vol. 8, no. 3, p. 397, 1999.

[4] J. M. Hill, M. J. Jennings, D. Vu To, and K. A. Williams, “Dynamics of

an elastic ball bouncing on an oscillating plane and the oscillon,” Applied

Mathematical Modelling, vol. 24, no. 10, pp. 715–732, 2000.

[5] J. Yunis, “Laboratory investigation of the dynamics of the inelastic bouncing

ball,” Aerospace Systems Design Lab, Georgia Institute of Technology, Atlanta,

2011.

[6] C. Rodesney, P. Gray, J. Yunis, and N. Arora, “Completely inelastic bouncing

ball on a forced plate,” School of Physics, Georgia Institute of Technology,

Atlanta, 2011.

[7] S. N. Rasband, Chaotic dynamics of nonlinear systems, vol. 1. 1997.

[8] T. Gilet, N. Vandewalle, and S. Dorbolo, “Completely inelastic ball,” Physical

Review E, vol. 79, no. 5, p. 055201, 2009.

[9] Mathworks, Inc., “Symbolic toolbox, MATLAB.”

[10] W. Szemplinska-Stupnicka, Chaos Bifurcations and Fractals Around Us: A

Brief Introduction, vol. 47. World Scientific Publishing Company, 2003.

35

A Code Listing

This appendix contains the two scripts for modelling systems described in this

dissertation. The first, bounce_system, takes a plate function and its respective

parameters (amplitude A and frequency ω). There is also the flag for whether or

not to display a plot of the system – 0 will suppress the plot. This is an example

use of this function:

>> g = 9.80665;

>> Ts = bounce_system(@(A,p) A*cos(p),{1,sqrt(g*4)},1);

Running this code will create the plot in Figure 2 (without the dashed line). It

will also return the bounce times and store as variable Ts. Note that frequency is

given in the form sqrt(g*4). This means that Γ = 4, since it is calculated from

frequency (and A = 1). g is a variable storing the acceleration due to gravity

constant.

The second script, bounce_ceiling, is based on bounce_system. This

function models the upper bounded system and takes in the same plate inputs,

but with the addition of a ceiling function and parameters.

>> Ts = bounce_ceiling(@(A,p) A*cos(p),@(A,p) A,...

{1,sqrt(g*4},{sqrt(g*7),1},1);

This is a call to model the simple oscillating plate and a constant ceiling. The

reduced acceleration is again Γ = 4, and the ceiling is set to constantly be at

height x = 7 in the dimensionless model. Note that even though the ceiling

function is only dependent on a single variable, it has calls for both A and p. This

is necessary for the generalised code.

36

function Ts = bounce_system(plate_func,params,display) %BOUNCE_SYSTEM is a function that takes in a vibrational plate function %and appropriate amplitude and frequency parameters and creates a inelestic %bouncung ball model, returning an array of flight times experienced by the %ball. % Input: % plate_func : function handle to model plate for two parameters % (amplitude and phase) % params : cell containing parameters of amplitutde and % frequency [amplitude optional, default: 1] % display : flag of whether to plot model % Output: % Ts : vector containing all unique flight times experienced % by ball from point it leaves plate %========================================================================== % Setup variables % %=================% t = 0:0.001:5*pi; % Time set - resolution 0.001

switch length(params) % Check parameter input case 1 % Default amplitude to 1 freq = params; ampl = 1; case 2 freq = params{1}; ampl = params{2}; otherwise % Handle error error('Plate function parameters cannot be properly handled'); end

phi = freq.*t; % Setup phase vector g = 9.80665; % Setup acceleration due to gravity constant Gamma = ampl*(freq^2)/g; % Reduced acceleration

clear params ampl %========================================================================== % Handle plate equations % %========================% func_var = symvar(sym(plate_func)); % Count variables on plate assert(length(func_var) == 2); % Check number of parameters is equal to 2 plate_acce = matlabFunction(-diff(sym(plate_func),func_var(2),2)); % ^- Convert to symbolic function, differentiate twice w.r.t. time % and convert back to MATLAB function handle % - equivalent to acceleration

x_p = plate_acce(Gamma,phi); % Calculate acceleration along time array x_p_grad = gradient(x_p); % Find rate of change in acceleration [~,locs] = findpeaks(-abs(x_p - 1)); % Identify peak change locs = sort(locs(x_p_grad(locs) >= 0)); % Isolate positive change departure_phi = phi(locs); % Assume ball \could\ leave at these locations

clear locs x_p_grad func_var %========================================================================== % Setup model % %=============% phi_0 = min(departure_phi); % Begin model at first depature point

x_p = plate_func(Gamma,phi); % Calculate plate location at all points

k = 1; start = 1; % Initialise loop variables epsl = -1e-4; % Numerical error limit Ts = freq; % Min first flight time phis = []; % Setup vector to save actual ball departure points ball_func = create_ball_func(plate_func); % Generate flight function ball

clear freq %========================================================================== % Simulation % %============% while (start || (phis(k-1) < max(phi))) % Limit by time parameter

T = 0.001; % Initialise flight time step bx = ball_func(Gamma,phi_0,phi_0+T); % Ball position at departure px = plate_func(Gamma,phi_0+T); % Plate position at departure

if (bx-px) < epsl, break; end % Check for numerical errors

while bx >= px + epsl % Check for flight end T = T + 0.001; % Increment flight time bx = ball_func(Gamma,phi_0,phi_0+T); % Recalculate ball position px = plate_func(Gamma,phi_0+T); % Recalculate plate position end

Ts(k) = T; % Save flight time phis(k) = phi_0; % Save flight departure point k = k+1; % Increment number of landings

phi_0 = phi_0 + T; % Increment flight position

departure_phi(departure_phi < phi_0) = []; % ^- Remove points of departure surpassed by plate

if plate_acce(Gamma,phi_0) <= 1 % Check if departure not immediate [~,idx] = min(departure_phi - phi_0); % Identify next position phi_0 = departure_phi(idx); % Set to flight point if isempty(phi_0), break, end % Handle lack of phi end

if length(Ts) > 50, break; end % Break if maximum iterations exceeded start = 0; % Remove loop initialiser end

clear start bx px T idx phi_0 departure_phi k espl %========================================================================== % Visualisation % %===============% if display figure % Open display window mphi = max(phis) + Ts(end); % Identify maximum time point tstep = (max(phi)-min(phi))/(phi(2)-phi(1)) + 1; % Generate time step if mphi > max(phi) % If limitable phi = min(phi):(mphi-min(phi))/tstep:mphi; % Create plot time array

x_p = plate_func(Gamma,phi); % Calculate plate location for time end plot(phi,x_p); % Plot plate function

hold on % Hold figure for i = 1:length(phis) % For each flight phi_0 = phis(i); % Calculate take off point T = Ts(mod(i-1,length(Ts)) + 1); % Allow repeatable model phi_n = phi_0:0.01:phi_0 + T; % Create discrete time points

% Plot depature and landing as points and ball flight as solid line plot(phi_0,plate_func(Gamma,phi_0),'ro',... 'LineWidth',1,'MarkerSize',10) plot(phi_n,ball_func(Gamma,phi_0,phi_n),'k') plot(phi_0+T,plate_func(Gamma,phi_0+T),'kx',... 'LineWidth',1,'MarkerSize',10) end hold off % Lock figure end

end %========================================================================== function ball_func = create_ball_func(plate_func) %CREATE_BALL_FUNC uses the symbolic toolbox to generate a ball bouncing %model based on an oscillating plate function % Input : % plate_func : function handle for oscillating plate with two % input parameters [amplitude, phase] % Output : % ball_func : function handle for ball flight with three input % parameters [acceleration, initial time, current time] %========================================================================== syms phi_n % Generate symbolic variable

plate_func = sym(plate_func); % Convert to symbolic function func_var = symvar(plate_func); % Isolate symbolic variables phi_0 = func_var(end); % Take phase variable of plate as initial time ball_func = plate_func - ... % Create ball function from plate position diff(plate_func,phi_0).*(phi_0 - phi_n) - ... % width velocity x time (((phi_0 - phi_n).^2)/2); % - half acceleration x time squared

ball_func = matlabFunction(ball_func); % Convert to function handle end

function Ts = bounce_ceiling(plate_func,ceil_func,params1,params2,display) %BOUNCE_CEILING is a function that takes in a vibrational plate function %and a continuous ceiling function, along with appropriate amplitude and %frequency parameters, and creates an inelastic bouncing ball model bounded %by the ceiling. Returns an array of flight times experienced by the ball. % Input: % plate_func : function handle to model plate for two parameters % (amplitude and phase) % ceil_func : function handle to model ceiling for two parameters % (amplitude and phase) % params1 : cell containing plate parameters of amplitude and % frequency [amplitude optional, default: 1] % params2 : cell containing ceiling parameters of amplitude and % frequency [amplitude optional, default: 1] % display : flag of whether to plot model % Output: % Ts : vector containing all unique flight times experienced % by ball from point it leaves plate %========================================================================== % Setup variables % %=================% t = 0:0.001:3*pi; % Time set - resolution 0.001

switch length(params1) % Check parameter input for plate case 1 % Default amplitude to 1 freq = params1; ampl = 1; case 2 freq = params1{1}; ampl = params1{2}; otherwise % Handle error error('Plate function parameters cannot be properly handled'); end

switch length(params2) % Check paramter input for ceiling case 1 % Default amplitude to 1 freq2 = params2; ampl2 = 1; case 2 freq2 = params2{1}; ampl2 = params2{2}; otherwise % Handle error error('Ceiling function parameters cannot be properly handled'); end

phi = freq.*t; % Setup phase vector (plate) rho = freq2.*t; % Setup phase vector (ceiling) g = 9.80665; % Setup acceleration due to gravity constant Gamma = ampl*(freq^2)/g; % Reduced acceleration (plate) Kappa = ampl2*(freq2^2)/g; % Reduced acceleration (ceiling)

clear params params2 ampl %========================================================================== % Handle plate and ceiling equations % %====================================% func_var = symvar(sym(plate_func)); % Count variables on plate

assert(length(func_var) == 2); % Check number of parameters is equal to 2 plate_acce = matlabFunction(-diff(sym(plate_func),func_var(2),2)); % ^- Convert to symbolic function, differentiate twice w.r.t. time % and convert back to MATLAB function handle % - equivalent to acceleration

x_p = plate_acce(Gamma,phi); % Calculate acceleration along time array x_p_grad = gradient(x_p); % Find rate of change in acceleration [~,locs] = findpeaks(-abs(x_p - 1)); % Identify peak change locs = sort(locs(x_p_grad(locs) >= 0)); % Isolate positive change departure_phi = phi(locs); % Assume ball \could\ leave at these locations

ceil_sym = sym(ceil_func); % Convert to symbolic function ceil_var = symvar(ceil_sym); % Identify number of variables if length(ceil_var) == 1 % Constant ceiling function ceil_acce = @(A,p) 0; % Acceleration set to zero for all points else % Vibrating plate ceil_acce = matlabFunction(-diff(ceil_func,ceil_var(2),2)); end % ^- Differentiate twice w.r.t time and convert back to MATLAB % function handle - equivalent to acceleration

clear locs x_p_grad func_var p %========================================================================== % Setup model % %=============% phi_0 = min(departure_phi); % Begin model at first depature point x_p = plate_func(Gamma,phi); % Calculate plate location at all points

k = 1; l = 1; start = 1; bounded = 0; % Initialise loop variables epsl = -1e-4; % Numerical error limit Ts = freq; % Min first flight time phis = []; % Setup vector to save actual ball departure points phib = []; ball_func = create_ball_func(plate_func); % Generate flight function ball drop_func = create_ball_drop_func(ceil_func); % ^- Generate function to model ball dropping after hitting plate

%========================================================================== % Simulation % %============% while (start || (phis(k-1) < max(phi))) % Limit by time parameter

T = 0.001; % Initialise flight time step bx = ball_func(Gamma,phi_0,phi_0+T); % Ball position at departure px = plate_func(Gamma,phi_0+T); % Plate position at departure

if (bx-px) < epsl, break; end % Check for numerical errors

while bx >= px + epsl % Check for flight end T = T + 0.001; % Increment flight time if bounded % Has already collided with plate p_dif = phi_b - freq2*(phi_b/freq); % ^- Change plate phase values to correspond with ceiling bx = drop_func(Kappa,freq2*(phi_b/freq),T - p_dif + phi_0); % ^- Calculate falling ball position

else phi_b = []; % No bounce has occured - reset current collision bx = ball_func(Gamma,phi_0,phi_0+T); % Recalc ball position end px = plate_func(Gamma,phi_0+T); % Recalculate plate position

if bx >= ceil_func(Kappa,freq2*(phi_0+T)/freq) && ... (-ceil_acce(Kappa,freq2*(phi_0+T)/freq) < 1 || ~bounded) % ^- Check ball is colliding with plate or ceiling % acceleration is greater than gravity if ~bounded % Handle collision phi_h = phi_0+T; % Save collision time bounded = 1; end phi_b = phi_0+T; % Increment time after ball leaves plate end end

bounded = 0; % Reset collision outside bounce loop

Ts(k) = T; % Save flight time phis(k) = phi_0; % Save flight departure point k = k+1; % Increment number of landings

if ~isempty(phi_b) % If collision occurred, save respective times phib(l,1) = phi_b; % Ball leaves ceiling phib(l,2) = phi_h; % Ball hits ceiling l = l+1; % Increment number of collisions end

phi_0 = phi_0 + T; % Increment flight position

departure_phi(departure_phi < phi_0) = []; % ^- Remove points of departure surpassed by plate

if plate_acce(Gamma,phi_0) <= 1 % Check if departure not immediate [~,idx] = min(departure_phi - phi_0); % Identify next position phi_0 = departure_phi(idx); % Set to flight point if isempty(phi_0), break, end % Handle lack of phi end

if length(Ts) > 50, break; end % Break if maximum iterations exceeded start = 0; % Remove loop initialiser end

clear start bx px T idx phi_0 departure_phi k l espl %========================================================================== % Visualisation % %===============% if display figure % Open display window mphi = max(phis) + Ts(end); % Identify maximum time point tstep = (max(phi)-min(phi))/(phi(2)-phi(1)) + 1; % Generate time step if mphi > max(phi) % If limitable phi = min(phi):(mphi-min(phi))/tstep:mphi; % Create plot time array

x_p = plate_func(Gamma,phi); % Calculate plate location for time rho = min(rho):freq2*((mphi-min(phi))/freq)/tstep:freq2*(mphi/freq); % ^- Create ceiling time array for plot end plot(phi,x_p,'LineWidth',2); % Plot plate function

hold on % Hold figure

r_p = ceil_func(Kappa,rho); % Calculate ceiling location for time plot(phi,r_p,'g','LineWidth',2); % Plot ceiling function

l = 1; % Internal loop variable for i = 1:length(phis) % For each flight phi_0 = phis(i); % Calculate take off point T = Ts(mod(i-1,length(Ts)) + 1); % Allow repeatable model plot(phi_0,plate_func(Gamma,phi_0),'ro',... 'LineWidth',3,'MarkerSize',10) % Plot departure point if ~isempty(phib) && phi_0 + T > phib(l,1) % ^- If collision occurs during current flight phi_b = phib(l,1); % Get drop position phi_h = phib(l,2); % Get collision position phi_n = phi_0:0.01:phi_h; % Flight up to collision phi_m = phi_b:0.01:phi_0+T; % Flight from drop to plate % Plot ball flight to and from ceiling as solid lines and mark % collision and drop points plot(phi_n,ball_func(Gamma,phi_0,phi_n),'k','LineWidth',2) % ^- Initial flight plot(phi_h,ceil_func(Kappa,freq2*(phi_h/freq)),'kx',... 'LineWidth',3,'MarkerSize',15) % Collision plot(phi_b,ceil_func(Kappa,freq2*(phi_b/freq)),'ro',... 'LineWidth',3,'MarkerSize',10) % Drop

p_dif = phi_b - freq2*(phi_b/freq); % Adapt phase values bx = drop_func(Kappa,freq2*(phi_b/freq),phi_m-p_dif); % ^- Calculate ball falling trajectory plot(phi_m,bx,'k','LineWidth',2) % Plot ball falling l = l + 1; if l > length(phib(:,1)), break, end % ^- Increment collision else % If no collision occurs plot natural flight phi_n = phi_0:0.01:phi_0 + T; % Create discrete time points plot(phi_n,ball_func(Gamma,phi_0,phi_n),'k','LineWidth',2) % ^- Plot ball flight end

% Plot ball landing on plate markers plot(phi_0+T,plate_func(Gamma,phi_0+T),'kx',... 'LineWidth',3,'MarkerSize',15) end hold off % Lock figure

% Adjust figure parameters xlabel('\omegat','FontSize',20); ylabel('x','FontSize',20); set(gca,'FontSize',16); xlim([0,phi_n(end)]) end

end %========================================================================== function ball_func = create_ball_drop_func(ceil_func) %CREATE_BALL_DROP_FUNC uses the symbolic toolbox to generate a ball falling % model based on a ceiling function % Input : % ceil_func : function handle for ceiling function with two % input parameters [amplitude, phase] % Output : % ball_func : function handle for ball flight with three input % parameters [acceleration, initial time, current time] %========================================================================== warning('off','symbolic:mupadmex:MuPADTextWarning') % ^- Remove warning about symbolic function handles % Function used are known to be valid %========================================================================== syms phi_n phi_b % Generate symbolic variable

ceil_func_s = sym(ceil_func); % Convert to symbolic function func_var = symvar(ceil_func_s); % Isolate symbolic variables if length(func_var) == 1 % Handle if constant ceiling ball_func = ceil_func_s - 0.5*((phi_b - phi_n).^2); % ^- The ball has zero velocity at initial point, so drops freely else phi_0 = func_var(end); % Take phase variable of ceiling as initial time ceil_velo = diff(ceil_func_s,phi_0); % Velocity of ceiling time_parm = (phi_0 - phi_n); % Time passed since collision fall_traj = (((time_parm).^2)/2); % Free fall on dimensionless system

% Due to inclusion of double(ceil_velo) - a check for only downwards % velocity - the need to evaluate as a string to override symbolic % toolbox limitations is need. This works as if typed directly into % the command and could not be handled simple with intermediate % variables

handl = ''; % Initialise handle string for i = 1:length(func_var) % For all variables, create eval string handl = strcat(handl,sprintf('%s,',char(func_var(i)))); end handl(end) = []; % Remove trailing comma

% Evaluation string handles each individual part as its own symbolic % function made from function handles and combines to create symbolic % version of ball drop function evalstr = strcat(... sprintf('ball_func=sym(@(%s)%s)-',handl,char(ceil_func_s)),... sprintf('sym(@(%s)double(%s<1).*(%s))*',... handl,char(ceil_velo),char(ceil_velo)),... sprintf('sym(@(%s,phi_n)%s)-',handl,char(time_parm)),... sprintf('sym(@(%s,phi_n)%s);',handl,char(fall_traj)));

eval(evalstr); % Evaluate string end

ball_func = matlabFunction(ball_func); % Convert to function handle

warning('on','symbolic:mupadmex:MuPADTextWarning') % Reset warnings end