The candidate confirms that the work submitted is their own and the appropriate credit has been given where reference has been made to the work of others. I understand that failure to attribute material which is obtained from another source may be considered as plagiarism. (Signature of student):

The Uses of Automata with

Application to Self-organising

Networks

Eiman Al-Abdulla

BSc Computer Science

2010/2011

II

Summary

Automata have been used to model the behaviour of various systems in a world full of integrated

systems. This project surveys the uses of types of automata in real world. Different types of automata

were explored in this project, providing different application for automata. Recent research in

telecommunications has investigated the use of self-organised networks for deploying the next

generation of communication networks. One of the approaches using these networks is cellular

automata. This project developed simulation software showing how the new communication network

serving the fourth-generation mobile devices is deployed using cellular automata. The simulation

software examined the performance of these networks deployed in geographical areas by cellular

automata.

III

Acknowledgments

I would like to thank my supervisor Dr Martin Dyer for his help and guidance throughout the progress of

this project. I would also like to thank my assessor Dr Matthew Hubbard for his feedback in the mid

report. Thanks go to my family and friends who supported me at every stage of this project. Finally,

thanks are due to all those who helped me reviewing and proofreading this report.

IV

Contents Summary ....................................................................................................................................................... II

Acknowledgments ........................................................................................................................................ III

Chapter 1: Introduction ................................................................................................................................ 1

1.1 Aim ................................................................................................................................................ 1

1.2 Overview ....................................................................................................................................... 1

1.3 Objectives...................................................................................................................................... 1

1.4 Minimum requirements ................................................................................................................ 2

Chapter 2: Project planning and methodology ............................................................................................. 3

2.1 Project plan ................................................................................................................................... 3

2.2 Methodology ................................................................................................................................. 4

2.2.1 Report methodology ............................................................................................................. 4

2.1.1 Software methodology ......................................................................................................... 5

Chapter 3: Uses of automat .......................................................................................................................... 6

3.1 Introduction to automata ............................................................................................................. 6

3.2 Language modelling using PA ....................................................................................................... 8

3.3 Model checking using pushdown automata ............................................................................... 10

3.4 Scheduling using timed automata .............................................................................................. 14

3.5 Cellular automata ........................................................................................................................ 17

Chapter 4 Design and implementation of the software ............................................................................. 22

4.1 Design .......................................................................................................................................... 22

4.1.1 Background of communication systems ............................................................................. 22

4.1.2 Design of simulation software ............................................................................................ 25

4.2 Implementation of cellular automata to W-SON ........................................................................ 29

Chapter 5: Results and evaluation .............................................................................................................. 33

5.1 Results ......................................................................................................................................... 33

V

5.2 Evaluation ................................................................................................................................... 37

5.2.1 Evaluating network structures with same number of nodes .............................................. 37

5.2.2 Evaluating network and time execution over the increasing of nodes .............................. 42

5.3 Further work ............................................................................................................................... 44

Bibliography ................................................................................................................................................ 45

Appendix A: Personal reflection ................................................................................................................. 48

Appendix B: Programming code ................................................................................................................. 49

1

Chapter 1: Introduction

1. Introduction

1.1 Aim

The aim of this project is first to study the uses of probabilistic, pushdown, timed and cellular automata

by providing an application to these types in real-life systems. This includes illustrating the definition,

structure and type of problems that is modelled by each type. Secondly, this project aims to produce

simulation software which models the behaviour of self-configured and self-deployed wireless access

point networks.

1.2 Overview

The information revolution has affected almost every aspect of our lives. Computers, now, are able to

solve problems that used to be considered hard to solve, time consuming or even impossible unsolvable

in a reasonable period of time. The modern world consists of integrated systems, and to improve it, it is

important to have a complete knowledge of each system, its components, its behaviour and how it is

related to other systems, to model, study and, ultimately, solve its problems. In order to solve such

problems, it is necessary to model them. Modelling in computer science can be done in different ways,

depending on the kind of problem modelled. One way of modelling real-life problems is by using

automata, which model the behaviour of real-life systems such as operating systems, computers,

electrical circuits etc. Automata are used not only for modelling problems, but also for producing

solutions to problems. Hand recognition is one application using automata to improve technology.

Automata are suitable to model different kind of networks and to simulate their behaviour, especially

when a system consists of components that are working concurrently. Modelling and production of a

solution can only take place when the system, its associated problem and automata have been clearly

defined and fully studied and the solution methodology has been well explained.

1.3 Objectives

The objectives of this project are:

to understand automata and their classes,

2

to show the ability of automata to be adapted in real life by showing how they are applied and

used in business and science,

to discover how automata are involved to improve the revolution of communication networks,

to introduce new aspect of networks modelled by cellular automata and

to show how each node in this system behaves with others in the network.

1.4 Minimum requirements

The minimum requirements of this project are:

to explain how automata are used by demonstrating their applications and

to provide software that simulates self-deployment and self-configuration in a self-organised

wireless network as an application of cellular automata.

3

Chapter 2: Project planning and methodology

2 Project planning and methodology

2.1 Project plan

In order to take advantage of the time given to complete this project, the work was split into reading

background material and searching the literature and writing background material and programming

software. The background reading provided the basis for an overview of automata and wireless network

architecture, described in Chapter 3 and part of Chapter 4. The other part of the project was dedicated

to computer programming and result writing and evaluation. From the beginning, there was a plan to

produce simulation software, modelling train roots on Qatar geographic map. However, it was very

simple, as the map was very small. Thus, it took only two weeks to find an ideal model for cellular

automata.

Particular attention was given to reading, literature searching and writing in order to complete the

reading part of the project while the programming had slow progress. Priority was given to provide a

small demonstration of the software; this changed the project plan, where more time was spent for

coding and getting a view of simulation for the demonstration. By that time, most of the reading part of

the project was finished; however, completing the simulation early was more important as it would have

allowed a more thorough evaluation of the simulation, most likely leading to a better result.

The progress of the project is provided in the table below:

4

Project

weeks

1 2 3 4 5 6 7 8 9 Easter

break

10

Writing

Research and

reading

Chapter 1

Chapter 2

Chapter 3

Chapter 4

Chapter 5

Personal

reflection

and summary

Proof reading

Coding

Application

Node

Draw

Table 1: Progress of the project

2.2 Methodology

2.2.1 Report methodology

The report surveys the uses of automata in different fields describing one application for each field

mentioned. Chapter 1 illustrates the aim, objectives and minimum requirements of this report, giving

also an overview of the information processing revolution. In Chapter 2, the project plan and

methodology are explained. Chapter 3 gives an introduction about automata and their classes. It

explains the application of probabilistic, pushdown and timed automata by defining their structures, the

problems they are solving and how automata were applied to solve these problems. Moreover, this

chapter gives an introduction to cellular automata and their recent models. Chapter 4 illustrates the

problems of current wireless networks and the move to the next generation of communication

networks. It also describes the recent research that relates the new generation networks to cellular

automata. Subsequently, Chapter 4 describes the methodology proposed by the Bell Labs for the case

study of wireless access point networks and self-organised networks [1], also illustrating the display of

5

the model. This project models this case study on a smaller wireless network to measure the energy

used in the network. Interpretation of the design is explained along with its implementation, which

demonstrates the behaviour of the simulation in relation to the real network and cellular automata

system. A self-organised Bluetooth network is simulated to define its behaviour and to determine the

improvement of the model by measuring the rate of change without compromising the performance of

the network. The final chapter, Chapter 5, describes the results of the simulation and an evaluation of

the analysis of measurements based on these results.

2.1.1 Software methodology

The software provided simulates the algorithm proposed by the Bell Labs researchers [1]. Java was used

to program the simulation as it is one of the object-oriented programming languages designed for

simulation. The software, however, was modified in order to evaluate the network assuming it was

applied in a real geographic area. In order to represent such a model, an object-oriented programming

language is ideal. The paradigm of these languages is based on creating different classes, where each

class represents an object in the model. Java also includes graphical libraries that can construct and

manage graphical shapes as objects. The software is based on the Java programming language; classes

built in Java can be easily modified and the structure of the program can be well organised.

Furthermore, Java is a base of many commercial and communicational applications.

6

Chapter 3: Uses of automat

3 Uses of automata

3.1 Introduction to automata

Automata were first introduced in the 1930s by Turing, who invented the Turing machine to determine

the boundaries of computer abilities. In the 1940s and 1950s, finite-state automata were introduced to

model brain function. In the late 1960s, Cook improved the idea of Turing machines by distinguishing

between solvable problems and NP hard problems. The latter are problems that can be solved

theoretically by a computer; however they need longer computation times. Automata are also used in

linguistic studies. Today, using automata, linguistic researchers are able to extract information from text

and to recognise hand written words by constructing software to do so [2], [3].

Automata are classified as regular languages (RLs) that include finite (FA) and cellular automata, regular

expressions, and context-free grammars (CFGs) languages, including parse trees and pushdown

automata. Some of these types are expanded to more complex ones; however, they are all based on the

same idea. Any type of automata has the idea of transition from one point to another. For example, RLs

indicate the set of states, among which a transition is made. However, CFGs indicate a set of variables,

for which there is a set of rules representing the recursive nature of CFG languages and a set of states

similar to the RLs [2].

Automata in RLs consist of:

the alphabet ∑, which is a finite set of symbols used to generate strings,

the set ∑* of all strings over the alphabet ∑,

the string ω in the language ∑, which is a finite or infinite sequence of alphabet symbols and a

member of ∑*,

the finite set of states ,

the start (or initial) state qo, where the automata will read the first symbol of the input string

and will initiate the transition form,

7

the final state (or states) q+, where the transition terminates and which show weather the input

string is accepted by the language of the automation being modelled and

the transition function δ, which represents the movement between the states and the

behaviour of the model. The function depends on the type of automata been used to model the

problem; thus, operations used in the transition function may differ among different

applications.

As described earlier, FA are one of the RLs, having a finite set of states to be used. FA are further

classified as deterministic (DFA) or non-deterministic (NFA). NFA can be classified according to whether

their input string is finite or infinite; in the latter case, they are called ω-automata. One feature added to

DFA and NFA is the epsilon transition (𝓔-transition). It enables DFA and NFA with finite input strings to

accept empty strings or to go to acceptance state even when there is no real input string at all. The

importance of this feature will be shown in section 3.4. The difference between DFA and NFA will be

used later in this report; thus it is important to illustrate this difference in advance.

DFA and NFA have the same basic structure of automata as described above; however they differ in the

transition function. The transition function of DFA requires one state and one symbol of the alphabet for

its input to return a new single state as an output. DFA are called decidable automata because they are

able to decide what the output should be. In contrast, NFA are able to guess the output, based on the

input given. The transition function of these automata takes one state and one symbol as an input, but it

returns a set of states as an output.

Automata in CFGs have a similar structure as those in RLs, where they execute the input and, based on

the given rule, they make the next move. However, there are still some differences between RLs and

CFG languages, as illustrated below:

the set of states in RLs is replaced by a set of variables, where each variable represents a set

of strings or a language,

the start state (or states) is also replaced by only one start variable,

the transition function used in a RL becomes a set of functions in CFG languages, which are

called productions functions and work recursively on each variable,

8

the nature of a CFG language is not decidable, meaning that there are no accept or reject

variables in its components; thus, there is no appear to final state in CFG. Instead, CFG

languages define a new language by a given set of rules and, finally,

a RL operates on the alphabet in each string to determine whether the string is a member of

the given language, while a CFG language defines or forms a language recursively using GFC

rules.

In this chapter, probabilistic (PA), pushdown, timed and cellular automata are introduced. The definition

and the structure of each type are provided, together with a description of the problems it can solve and

the corresponding solution. The patterns of automata used in different ways and modelling different

behaviours are shown. Moreover, a description of how the automata have been applied to solve

different kinds of problems is included.

3.2 Language modelling using PA

PA are one of RLs in automata. They are classified as finite automata with a feature which is associated

with probability. PA have been developed to model and analyse synchronous and concurrent systems

with probabilistic choices. PA are used to model a system that has many different behaviours, where the

probability part in the automata corresponds to the probability that the behaviour the system will take it

from a particular point to go to another point. This point is a member of a set of points which is

modelled as a set of states in the PA. In addition, the behaviour in that system is translated as the

transition function in the automata which depends on the probability of the set of the next state.

It has been shown that there is similarity between NFA and PA, suggesting that PA can be classified as

NFA [4]. In both these types of automata there are many transitions exiting the same state; thus, it is

important to illustrate that there is a difference between PA and NFA in terms of modelling a system. PA

are considered as DFA and the transition of PA models corresponds to many different behaviours of the

system in the same state. In contrast, the transition of NFA models the changes of the system’s states,

so it is not considered as PA.

According to Marelle [4] a PA, denoted as ρA, consists of the following:

a set QA of states,

a set of start states S0A which is a member of QA,

9

a set of all probability distributions over QA, which is denoted as Distr(QA),

an action signature sigA = (VA, IA), which constructed by internal and external actions, where VA≠

IA. ActA = VA IA and

a transition relation (function) ΔA QA × ActA × Distr(QA).

The action in PA is several transitions with the same labels leaving from the same state. The internal and

external actions consist of internal and external choices. Internal choices in actions are probability

choices that are made by the automaton and are independent from the environment. The external

choices are probability choices that can be affected by the system environment [4].

The transition of PA requires one state, a set of internal and external actions made at this state and the

probability distribution over the set of states QA as input. Processing these three components together

will output the new state which has the highest probability in the set of probability distributions. In

addition, this transition depends on the probability of the next state rather than the symbol of language

used.

Researchers in natural language processing (NLP) found a new approach to represent language models

by using PA. In NLP, PA can be used, where a word or sequence of words can be given a probability value

to verify which word or sequence of words is more likely to be correct. Applying this idea can be used to

improve the accuracy of existing applications such as speech recognition [3].

To date, language models are based on N-gram theory which distributes the probability of word bases

on the frequency of their appearance after the previous N words in the set of texts. This set of texts,

called corpus, has been collected according to specific criteria and is used later as training data for

Figure 1: Probabilistic automata and transition example, reproduced from [4].

10

language modelling. Using N-gram models is useful as they are efficient to implement; however, the

structure of these models is too simple to be able to implement more complex languages, which has led

the linguists to search for new techniques to model these languages, producing the same result as N-

grams. Thus, PA are founded to model such complex languages and to produce the results NLP

researchers aspire to [3].

Language modelling by PA consists of a number of nodes connected by arcs, where the first and the last

node are called start and end node, respectively. Arcs represent a word associated with its frequency.

However, the arcs entering the last node are marked by an expression rather than a word to indicate

that the next state is the final state of the automaton. Nodes record the path of words that appear after

each other in the corpus, which is similar to N-gram’s idea. In the transition function, each time the arc

is used, the frequency of the word in that arc increases and the next state depends on the highest

frequency of the previous state. The last arc is the last arc of the path that leads to the final state and it

is associated with the sequence of all words in the previous arcs, which means that these words are

more probable to occur in sequence [3].

In order to create such algorithms for language modelling, PA have to learn how to capture probabilistic

regularities in the corpus. Forward-backward algorithm, which is an algorithm constructed to compute

the prior probability in the hidden state of the hidden Markov model [5], has been applied to let arcs in

the probabilistic automaton be assigned with probabilities [3].

Research on NLP now aims to use these language models as a learning system, just like the probabilistic

learning system was used to generate these models. These models will then be used in speech

recognition, as an application of automata in NLP, as well [3].

3.3 Model checking using pushdown automata

Pushdown automata (PDA) belong to a class of CFG languages in automata that use a set of recursive

rules to define a language. Non-deterministic finite automaton with 𝓔-transition is the core of pushdown

automaton [2]. However, PDA have a special feature in automata which is not available in FA. PDA have

the ability to store unlimited amounts of information using a stack, where each item in the stack has

limited amount of information. The stack is also known as the external memory of automata [6]. The

order the stack is using to save and process this information is last–in-first-out mode. It will always

process the last item added on the top of the stack. PDA are considered as one of language-recognising

11

automata and recognise only CFG languages [2]. Thus, they are used as security, checkers for CFG

models.

PDA have a structure similar to FA in RLs, with the addition of stack symbol. PDA can be defined as

follows [2]:

𝓟 = (Q, ∑, Γ, δ, q0, Z0, F) is a PDA, where

Q is the finite set of states,

∑ is the alphabet of input symbols,

Γ is the stack’s alphabet, which is a set of symbols allowed to be pushed into the stack,

δ is transition function,

q0 is the initial state where the transition starts,

Z0 is the initial symbol in the stack before the transition starts and

F is the final (or accepting) state.

The transition function in PDA always aims to map the symbols of the stack with the input symbol if they

both match the function; the required operation will be executed by popping or inserting new

information to the stack, depending on the symbols in the input string, in order to move to the next

state. Execution of the transition function requires the current state, the input and the stack symbols.

The output of the function is a pair consisting of the new state and the next stack symbol. Although, the

basis of PDA is nondeterministic automata with 𝓔-transition, the next state of PDA is usually a single

state rather than a set of states, except for the final state, which is similar to NFA as there is a set of final

states that may also be empty. Figure 2 illustrates the transition behaviour in PDA.

Using normal PDA means that the lack of measurement caused by the use of non-determinism while

modelling the problem and applying it, will not be particularly useful. Thus, computer deterministic

pushdown has been introduced, operating differently from DFA. Deterministic pushdown automata

(DPDA) are based on preventing the automaton from making any choices in its transition and forcing the

automaton to execute the input and to follow the instruction to go to the next state. These choices can

be either input choices, where there is a choice to use an input or an empty string, or choices of moving

12

to a new state similar to NFA. In addition, using DPDA allows the automaton to recognise RLs as well as

CFG languages [2], [6]. However, normal PDA or nondeterministic PDA still can be used within a

modelling system where the main system model depends on finite states and a transition function.

Modelling a system requires a complete analysis with regard to its behaviour, input and output. It is also

important to test and verify the model. Model checking is a verification technique to test and verify a

model of a concurrent system. Reachability is one of the problems faced by model-checking software in

the testing stage of the model, because it is hard to predict whether the model will reach the final state

from the given point. A reachability algorithm is an algorithm constructed as a solution to a reachability

problem and it is applied in model checking software [7]. The algorithm is based on verifying input

strings reachable to a fixed point (or set of points).

Reachability in model checking is based on calculating either all points or variables form which a system

can reach a particular goal (or set of goals), or the set of all reachable goals. These points or variables

are called predecessors of goal X, if backward reachability is used, where the algorithm is calculating all

variables that led to the set. They are also called successors if forward algorithm is used, where the

variables are calculated as a result of the given set. In both types of algorithms, two types of automata

are combined and used in the reachability algorithm; one is the Büchi1 automata and the other is the

PDA. This allows model checking to use PDA with infinite input strings to perform the algorithm. In

addition, proposition logic frameworks are used in the model, due to a lack of reachability to keep track

of paths and runs2 in the running process of the model. Linear-time temporal logic (LTL) and branching-

1Finite automata are considered as NFA, but they use infinite sequence of strings as its input.

2A run in Büchi automata is an infinite sequence of states, where the first state in the sequence corresponds to an

initial state and the rest of the states are added once the transition accepts the input of the string.

Figure 2: Transition in pushdown automata, reproduced from [6].

13

temporal logic are two frameworks used in model-checking of finite and infinite automata systems,

respectively. We now briefly explain how the LTL framework and PDA system are used in model-

checking systems. The LTL framework in model checking is used to verify the finite state of a system. The

framework provides a set of proposition, prop, where the alphabet of automata will be constructed as

Σ= 2prop [8]. The algorithm will check whether a given input satisfies the rule of automata that allows the

model-checking software to determine whether the given initial configuration belongs to the set of

configuration pairs, based on the propositional framework in LTL [8].

The input pair of a pushdown automaton is called configuration pair in model checking. Every pair

stratifies the rule from which the final state can be reached, even in many transitions through the same

pair. It is considered as a member of set of languages accepted by the automata P. For both forward-

and backward-reachability algorithms, the input is an automaton A that accepts an RL C and new

automata are generated to calculate predecessors or successors of C. In the backward-reachability

algorithm, which calculates a predecessor, it is assumed that the initial state cannot be reached by any

of the given rules in A. A new automaton, called Apre*, is generated and calculates, recursively, pre*(C)

(which is also a language accepted by Apre*) until the initial states are reached. Based on the rules

outlined in [7], predecessor new transitions are calculated and added to A. Adding new transitions to A

is limited to the possibility of have new transitions for the given rules. The forward-reachability

algorithm uses the same input as the backward-reachability algorithm, but it creates a new automaton

Apsot* that calculates a successor of C as post*(C), which is also a language accepted by Apsot*. This

algorithm, however, consists of two stages. The first is adding a new state qp’, γ’, if there is at least one

transition of the form (p, γ) (p’, γ’ γ’’) for the pair (p’, γ’). The second is adding a new transition to A, if

one of the successor rules outlined in [7] occurs. A forward-reachability algorithm allows adding a new

state for a given pair; adding a new transition is also finite for same reason which holds for the

backward-reachability algorithm [7].

Model-checking applications use different types of automata for verifying models in system analysis.

This application is not as popular in the business world as it is in the scientific world, since it verifies

scientific models and in various applications, including physical systems, chemical models and some

programming languages.

14

3.4 Scheduling using timed automata

Timed automata also belong to the class of finite state automata in RLs. They are considered as part of

ω-automata. They are generally used to model real-life systems, considering the time constraints in

these systems. Some of real-life systems that timed automata can model include estimation of

transmission delays and fault tolerance. Normal finite automata are able to express and model the

events of systems regardless of the time constraints and the behaviour of that system. However, in the

real-life systems neither the time nor the events can be ignored as they both are essential keys in these

systems. The changes made in a system and their timing are the main issues addressed by timed

automata models. Workflow in such systems must be controlled and is restricted by time; this is an

important feature, considered in the theories specifying that system. Another aspect related to time

restriction to this type of automata is to verify the parameters that should be modelled in the system

[9], [10].

Timed automata differ from other types of automata because of their special feature which considers

the temporal dimension in the model. There is a set of time sequences Τ associated with the set of

infinite strings, which is a component of timed languages [10]. The time sequence is ordered

monotonically, where τi < τi+1 and i>1. A timed string/word ω = (αi,τi)1≤i≤p , where α is string over the

alphabet Σ, τ is the time sequence in T and both have the same length of sequence i [10]. The domain of

the time sequence is the set of positive real numbers and the set of positive integers is the domain of

the timed word [10].

The behaviour of each system is represented as one timed word. The transition functions between state

sets represent the change of behaviour of the system. To let the automaton make its choices upon a

time input sting (as Büchi automata do when there is a set of transitions that can be made at each

state), a set of clocks is associated with the timed automaton, which reads the value of time input.

Clocks can be reset concurrently at any transition, where the reading of a certain clock represents the

time past since the clock was last reset. One more set is needed to define timed automata. This is a set

of clock constraints, denoted as Φ(X), where X is the clock and Φ is the constraint and is used to identify

the type of constraints allowed in each transition. The most general constraint is to compare the value

of clock with a constant value which can be any integer value ≥ 0; Boolean values are used to model this

constraint. Another set in timed automata associated with the clock constraint set is called valuation

which is the time value υ from time sequence to each clock χ. The clock constraint will, then, return a

Boolean value, once it checks whether the given value υ satisfies the constraint of the clock χ [9], [10].

15

According to Drill and Rajeev [9], a timed automaton Α consists of a tuple (Σ, Q, Q0, C, E), where

Σ is the input string alphabet,

Q is the finite set of states,

Q0 Q, is the set of initial states,

C is the finite set of clocks and

E *Q x ∑ x 2C x Q x Φ(X)+ is the transition function of automata.

The transition in timed automata processes the input as a pair of one symbol and one time value at each

transition. Initially, all clocks are set to zero. The transition starts form a starting state at time 0 and, as

time is running, all clocks in the automata change to represent the time elapsed in the automaton. Once

Α reaches time τi, it changes the state from q to qi, and resets the clocks in the subset λ when the clock

value satisfies the clock constraint to return true value for the given clock value [9].

Scheduling is a typical time-related problem and many concurrent systems are affected by this problem.

Scheduling is a set of tasks performed simultaneously, using a limited number of shared resources [11].

Each task is determined by three characteristics, namely the execution period, the resources it needs to

access and the priority relationship among other tasks. The latter characteristic is important when two

or more tasks demand the same type of resource concurrently, a situation known as deadlock.

Scheduler software has been introduced as a solution to void such a conflict; it can give permission to a

particular task to use a particular resource for a limited period of time. This leads to a delay in the

execution of some tasks; thus, the scheduler needs to optimise its choice of giving permission to tasks.

The most popular scheduling problems are scheduling train times, operating systems and jobs [11].

Verification and specification are two features of timed automata systems concerning timing-related

problems. Timed automata have been used as an approach to model, study and analyse scheduler

software, illustrating its issues and the respective solutions [11]. Many scheduling problems such as job

scheduling in a shop and train diversion scheduling can be modelled by timed automata at different

constraints. Machine scheduling considers a set of tasks constrained by a partial order precedence

relationship that defines the immediate predecessors of the executed task. In the same problem, there

is a set of machines to execute tasks, where it is assumed that all machines are distinct and each task

can be executed only by a particular machine. Two functions are also defined in the problem; first,

function µ assigns a machine to each task and, secondly, function duration assigns the time for each task

to be executed [11].

16

A model for a scheduling problem aims to minimise the total execution time of all tasks based on the

following constraints:

task pi can be executed only if all its predecessors are terminated,

every machine can execute only one task at a time and

once a task is started, it cannot be blocked or cancelled.

Different kinds of scheduling problems can be modelled by timed automata with an aim to determine an

optimal schedule. Before starting modelling, the parameters and should be defined, in addition to

the duration and the predecessors of tasks. A timed word (q, v) in a scheduling model represents a pair

of task and time values. For each task pi, an automaton Α is generated with three states and one clock,

as shown in Figure 3. The states illustrate the status of a task pi, with the first state representing the

task waiting to be executed, the second state representing an active task and the third state indicating

the termination of that task. The constraint of the termination state will evaluate the duration of the

task to true to access the termination state. The clock will be reset when the transition reaches the

waiting state of the task. In this model the waiting state is considered to be the initial state in the

automaton. The clock of automaton starts once the automaton enters the active state which is

processing the task. Each run in the timed automaton represents a schedule to the problem, with the

shortest run indicating the optimal schedule for the given problem. This process is performed for each

task in the set; however it does not model the entire scheduling problem yet. A construction of an

automaton for each individual task will model the constraint of the predecessor relationship in the real

problem. This will ensure that a task will not be started before its predecessor tasks are in their final

state. Modelling such problems requires a finite input of time values and tasks have been used allowing

the automata to generate finite sequence of states in each run [11].

17

Timed automata are mostly used for modelling real systems and consider the time factor in these

systems. Scheduling is one of these systems. Using discrete steps and values and finite sequences in

timed automata has led to reducing the scheduling problem to the shortest path or run in automata by

using forward-reachability algorithms and adding one more clock to the timed automata [11].

3.5 Cellular automata

Cellular automata (CA) were first introduced in the late 1940s by Ulam and Von Neumann as a

mathematical structure [12]. By referring to the main classes of automata described earlier in the

report, CA are considered to be deterministic finite automata from RLs. CA have three main

characteristics: determinism, local interactions and discreteness in state values, place and time. An

automaton of CA is a finite dimensional grid of cells. Each cell has a finite set of states and defined

neighbour cells. CA have gained features of flexibility and scalability by those characteristics. As a result,

CA have been used to model a wide range of different systems such as physical, chemical and biological

ones, where the models are considered to be simple. Furthermore, these models helped to study the

systems in detail and with a relative ease [13].

According to their definition, CA will have a finite size of gird, number of states and time steps. The grid

in CA can be -dimensional where ≥1 and all cells in the grid are identical. One-dimensional CA are

represented as a row of cells. However, the formal definition of CA is usually as two-dimensional grids

used for modelling systems. The two-dimensional grid is represented as a square of finite cells. Each cell

has a set of states to alter with the minimum number of states being two. The changes between the

states in each cell are done by time stepping. Time steps is another finite set in CA used as time ticking

in a clock where the initial time step is set to zero in the initial states. The state value will be changed

Figure 3: Tasks in timed automata, reproduced from [11].

18

once the time step is met or a condition returned true or false value in the rule. The local transaction

function (or local rule) determines when a cell moves between its states from the current time step to

the next time step. All cells in the gird apply the same rule, taking into account the current state of the

cell and its neighbour in the previous time step of the automaton. Configuration of automata is done

when a value is assigned to the state values in the grid. As the entire grid is updated by using one rule

only, there is a nature of parallelism in CA as all cells in the grid update their state values simultaneously

[13], [14].

The local transaction function is a relationship that is applied by the cellular grid. However, the rule

space must be determined prior to defining the transition function to distinguish the global dynamic rule

from the local rule. Rule space is an equation representing the structure of CA by defining the

neighbourhood of cell . It is denoted as , where is the number of state in each cell and is the

number of cells to the left of cell c in an one-dimensional CA; there are also cells to the right of cell c.

Considering the example given by Schiff [13], in an one-dimensional CA for cell c, r=1 and k=2, the space

rule produces a neighbourhood of 8 ) cells for cell c. By modifying r and , new structures of

automata are defined. Using different rule spaces for the same rules produces different behaviours in

CA. The different structures of rule spaces that have been introduced have led computer scientists to

consider them as types of automata. These different structures have been proposed to simplify design

and analysis of CA behaviour in addition to make them more adaptable for modelling. For example, Von

Neumann, Codd and Arbib provided three different structures of two-dimensional cellular automata.

Although all structures had a five-cell neighbourhood, the number of states in each cell varied strongly

among the three structures, namely it was 29, 8 and 4, respectively. Generalising these structures,

neighbourhood configuration in CA has two types, known as Neumann and Moor neighbourhoods;

Neumann neighbourhood builds a five-cell neighbourhood while Moore neighbourhood builds a nine-

cell neighbourhood, regardless of the number of states used in each cell [13], [14], [15].

After configuring the cell neighbourhood, the rule is defined to be used in the local transition function.

The rule is normally a mathematical equation and is applied to each cell simultaneously.

represents the state value of the -th cell at time step , so the state value of the same cell after

applying the rule in the next time step is , which depends on the rule on and its

neighbours and in the one-dimensional case. Another index is added to index in the

two-dimensional CA. At each next time step, a new pattern for the same rule is represented and is

known as automata revolution [13]. This pattern is a sequence of states over the set of time steps for

19

one cell in the automata and is called rule table. The number of patterns is calculated by using the rule

space. Statistically, by assuming that there are two states in each cell; each cell in the neighbourhood

can alter between these two states in one step. This can be formulated as possible patterns in the

automata with s-neighbourhood and two states in each cell. As a result, new patterns for each cell will

be produced. Referring to the example of space rule above, when r=1 and k=2, then s = = 8 and,

therefore, there are possible patterns be produced by these automata. The general equation

for the local transition function in one-dimensional CA is

where is the transition function. CA with two states used in each cell and of the form described above

are usually known as elementary cellular automata each cell [13], [15].

A cellular automaton was formally defined by Tomassini [16] as , where:

is the finite set of state in each cell,

is the neighbourhood, where is the set of neighbours of the -th cell,

is the dimension of the grid used and

is the local transition function.

The CA model the change of behaviour of a system over time [13].

Modelling physical systems by CA

CA have been wildly used to model physical systems since the early 1970s. Firstly, Hardy, Pomeau and

Pazzis found that gas particles can be treated as CA. They provided a Boltzmann model which is used

Figure 4 : A 2D model of CA, reproduced from [13].

20

mainly for modelling granular media and flow of fluids. All these systems have similar microscopic scale,

but with different nature. The Boltzmann model consisted of a discrete number of dynamic particles,

vibrating and colliding in a two-dimensional grid to preserve the motion and the number of particles.

Over the years many models of different physical systems have been developed based on Boltzmann

model [17].

Recently, researchers from the University of Perpignan and the University of Geneva introduced a new

model using CA to represent water flow in an irrigation channel. It has been shown that traditional

irrigation systems waste large amounts of water, especially when the water is transported from water

resources to agriculture fields. Research was focused on the regulation of river systems and on the

development of automatic dam gates that control the water by providing different approaches to do so.

This dam gate has a gate opening control variable interacting with the water level or flow variable to

improve the irrigation system. As a result, the model that was developed represented the behaviour of

water flow in a reservoir with upstream and downstream gates and the effects of boundaries,

considering a bi-fluid model that simulated an open channel with free-level water [16].

A Boltzmann model was considered, having a discrete regular grid with a particular spacing distance,

and a discrete stepping clock. It was assumed that the water particles are entering the grid site at time

according to the possible directions of the site in the grid. As a physical system was modelled, density

distributions and the particle velocities should also be considered in the model. In this case, the motion

of the model or the local transition function among the grid sites was based on both densities and

velocity. They both depended on the vector of each site in the grid. The dynamics of the model steps,

however, depended on the density and velocity of each cell in the grid. The density distribution

represented the neighbourhood of the grid, while the velocity was the speed of each site. These steps

showed the states that each site would alternate between, as the time elapsed. The bi-fluid model

represented two different fluids in the water channel, namely water and air. Each site of the gird had

two immiscible fluids, while the global motion of that site took into account the motion of the two fluids

(water and air). The gravity force was applied in the water fluid to keep the water particles in the

bottom of the reservoir. The boundaries used in the model were used to fix the values of the density at

the boundaries. The function was calculated parallel to the grid and only between the nearest

neighbours. The densities of sites were moved to the closest neighbours in the first dynamic step, while

the second state transformed the incoming distribution into an outgoing distribution in the grid [16].

21

Modelling bi-fluid water flow in order to improve irrigation problem and saving water is one example of

modelling physical system using CA. Large-scale CA models in physics are used to analyse simple

behaviours. A system that contain homogeneity of cell types and the cells interact locally, is more

suitable to be modelled by CA, regardless of the nature of the system that the automata are modelling.

Chapter 5 provides another example of a model applying CA in communication systems and was

inherited from the physical system.

22

Chapter 4 Design and implementation of

the software

4 Simulating a self-organised wireless network by cellular automata

Cellular automata have been used widely for modelling systems in various fields; one of them is building

a network. As mentioned in section 3.5, cellular automata provide a simple system model to study the

behaviour and characteristics of the modelled system. In this chapter, cellular automata are used to

model a new kind of wireless network. Not only was the new network modelled by cellular automata

but it was also proposed deploying the network using cellular automata behaviour. This chapter will

illustrate wireless systems, and how they can be improved to become self-organised systems.

Communication systems, such as cellular, ad-hoc and wireless networks, are considered to be a part of

physical systems. These networks belong to different types of communication networks and it is

necessary to keep them isolated from each other. In order to interconnect them, we will introduce a

simulation of a new network which will be able to connect all these networks using IP addressing as

common protocol in the network. This simulation is an application of cellular automata related to

communication world.

4.1 Design

4.1.1 Background of communication systems

Wireless networks and wireless systems

A wireless network is a network that uses radio frequency (either short- or long-wave signal) to connect

its members. A cellular mobile network is an example of wireless network to connect to the public

telephone network. These networks are based on switching centres (or base stations) spread to cover

fixed limited areas. Each base station is a cell within a network covering a discrete zone (e.g.

neighbourhood), while this network is also a cell of a wider network (e.g., a city). A mobile user can

connect to at least one base station dynamically during a call once their device is in the coverage area. In

the first generation of mobile networks, the base station used to transmit voice data only. The

development of communications in the past 30 years turned this service to its third generation, allowing

23

the network, known as third-generation (3G) network, to provide image and video data, in addition to

voice transmitting [18], [19].

WLAN is consisting of two or more devices connected to each other using radio frequency. WMAN is

interconnected WLANs covering a city or any geographic area that use high-capacity technology to

provide a connection and Internet access to a wide-area network, such as a small city [20]. A computer

wireless network is made of several nodes connected together. Each node is a group of computers or

communication equipment (mobiles and new video games technologies) connected directly using IP

network. Each network is connected to other networks using routers (or hosts) of nodes that are

connected to each network. Different levels of IP address are used to define each network and each

computer connected to these networks [20], [21].

The next generation of wireless networks aims to standardise communication standards and network

protocol among WLAN and WMAN cellular nodes. As a result, the hierarchy structure of 3G cellular base

stations will disappear allowing them to connect to WLAN and WMAN, forming a new type of wireless

system known as heterogeneous wireless access network and using a new flat structure for such

network. The future vision of communication networks will enable mobile phones to connect to all the

above network types, concurrently. It will require deploying and configuring new base stations that will

have the ability to integrate these different wireless networks [18], [19], [22].

Self-organised wireless network

As the world is heading toward the deployment of the fourth-generation wireless access networks (4G

networks), the increase in the development of wireless technologies, this eventually will lead to a high

demand for quality and reliable services. Providing such mobility service will grow the complexity level

of a dynamic network and this will cause bigger work load on management resources. It is, thus,

necessary to resolve the current management issues for wireless networking [23].

Current networks are still fixed in size and structure and are centrally controlled. As a result, there is a

limitation to the independency of network connections which restricts flexibility and network size

scalability. Central control limits the independency of connections between the nodes of a network, as

the nodes usually revert back to the main server to identify and connect to other nodes. Furthermore,

the flexibility of changing the structure of a network is correlated with high costs and this is due to the

redeployment of the whole network system, when there is a need to change the structure. Another

24

issue concerning the current structure of wireless networks is that the scalability of adding new nodes or

removing unused nodes requires manual reconfiguration which inflates the budget of the original cost

of the network [23], [24].

Unlike the existing network systems, the self–organised systems provide more adaptability to the

growing needs of dynamic networks. Nature provides an inspiration for projecting ideal wireless

network behaviour that can be theoretically adopted to enhance the current network systems. Fish and

ants are two examples that illustrate the behaviour of a self-organised system. Fish swim forming a

particular pattern of structured group or shoals. Each individual fish defines the nearest position of at

least two others in their shoal. The networking system of ants also depends on identifying local

neighbours forming a functional trail to find the shortest path for food. These systems show the absence

of central control of managing a system, the flexibility of a structure that can be adjusted easily and the

freedom of scalability, as each new member joining the network system will only need to know its

function and position of its closest neighbours. In addition to scalability, adaptability is another feature

for a self-organising system, where the entities can recognise and adapt to changes in the network,

based on particular configuration behaviour rules. The application of this behaviour in science could

resolve many of the challenges; for example, in centre controlled systems [23].

A self-organised wireless network is considered to be a decentralised control or localised distributed

control network, behaving as a fish shoal. The nodes of this network have the ability to organise

themselves based on their given function and by connecting to each other directly and defining their

immediate neighbours. Resizing and reorganising the network is done automatically when the nodes of

a network recognise the need to do so. Another advantage of adopting a self-organised network is that

it provides self-optimisation; the network will always try to optimise its performance independently

from human interaction by measuring the changes in the network; for example network heavy loads.

The new structure of wireless network aims to minimise the cost of deploying, configuring and

decentralising the control management in order to optimise the performance of the whole network and,

eventually, the system [23], [24].

Ad-hoc network is another type of wireless network. It is also considered to be a self-organised network.

It works on connecting computers directly without using traditional routers and base stations. It is

considered to have a decentralised network as the network does not have a centre router to transfer

data and connect to the network. The computer in the network will have to explore itself to other

computers in the network to establish the connection between the computers forming the network.

25

However, the network is working on optimising its self-configuration based on the current location of

nodes, while several researchers are trying to provide a network that will have the tendency to choose

the location of nodes and the type of nodes required [1], [25].

4.1.2 Design of simulation software

Researchers in the Bell Labs proposed new methodologies and algorithms in a workshop in Berlin to

implement self-organised wireless access networks that will be self-deployed and self-configured [1].

One of the paradigms that they proposed is cellular automata. They detected some similarities between

CA and self-organised networks, as the interaction between cells in CA forms a global organised system.

This kind of interaction was the reason to adapt CA in self-organised wireless network. In addition, CA

provide the network with the ability to change its structure and size based on the current performance.

The case study they provided about applying CA showed the possibility to deploy a new network

generation based on CA. They proposed an algorithm that aimed to provide a network that will be able

to cover most of the designated area. In this study, a fine grid of 100 nodes (or base stations) was

structured to cover an area of 2,500 meters, with all nodes covering equal size areas. Moreover, the

coverage area of the node is considered to be a resizable cell. Once a node is deployed in the network,

it starts searching for its immediate neighbours and calculates their distances to set its cell size by

modifying the energy level it needs to provide radio frequency to its area. The nodes have to detect any

possible gaps between the node and its direct neighbours; thus, the second state of this algorithm was

to detect gaps between the neighbours and trying to fill those gaps. Each node will depend on the

feedback signals from the mobiles connected to it. The mobile is sending signals once the received

signals from the nodes get below the threshold. This signal indicates that there is a possible gap,

because the mobile device could have connected to a direct neighbour, if there is no gap. The node,

then, increases its coverage to cell size, based on the number of mobiles reporting a possible gap

between their neighbours. The base station is increased by the factor of a function to ensure that the

cell will expand gradually, based on the function to cover the possible gaps only:

where represents the number of gaps reported from the mobiles and is the difference between the

current size of the node and its original size. In the deployment stage some nodes within the coverage of

the same node ends up to be deactivated from the network [1].

26

That case study, however, raised further issues related to the clarification in the application of cellular

automata to wireless access networks. It is important to measure the rate of reduction of nodes that will

occur once the automata algorithm started. The modification of energy levels is also needed to be

calculated, as it will be interesting to measure the amount of energy wasted against the number of

nodes reduced in the network.

The software designed in this report simulates this study by applying the algorithm on a small wireless

Bluetooth network as a personal network in a floor of offices, in order to illustrate how Bluetooth

adapters pair with each other to set up the network. As the performance is the network changes, the

network is also able to reconfigure its structure using the same algorithm. A network model is applied by

representing the area of floor as a two-dimensional area.

The Bell Labs case study built a regular grid of base stations covering an equal size the area. In the

simulation model, however, it is assumed that the network is deployed in a real system, where node

locations are not strictly important. The model was designed to model a random network where its

network is randomly spread in area.

In the simulation, each individual network node applies three functions. First, it checks whether it covers

any other nodes. Then, it defines its closest neighbours creating a neighbourhood. Finally, it modifies its

coverage radius to fill in any gaps in between. The code simulates these functions one at a time.

However, in real networks each node applies these functions simultaneously.

The model is constructed by three classes developing interface, drawing network and an object class.

These classes are , and . is the main thread in the software,

executing the user interface apart from the Draw class and the computation in the model. The design of

the model, however, is based on the and classes, as their methods generate the global

behaviour of the network. is an object class which constructs the nodes. Each node has its

attributes of defining location, radius of the coverage, status of the node and a list providing all

neighbours. The class is the model foundation where all calculations and drawing are executed

using different threads. The object class contains methods that construct a node by setting values

to its attributes. It also includes a method to set and get each of these attributes, to modify and to reuse

them, by generating the object in the class.

27

The class is a class which executes the algorithm of simulating random structured network. Many

different variables and methods are used in this class due to the calculation and drawing required. The

threading used in the class gives an animated view of the behaviour of network.

The class is generating a list of type Node by the constructor , where the class is invoked to

generate node objects. These nodes and their coverage are drawn as ellipse shape object initialised as

graphic objects in 2D.

The method is the main method of drawing nodes in this model. It is based on

switching statements where the algorithm alternates to other cases once the condition is met. This

allows the user to distinguish the different states of the network. Drawing shapes in the model is based

on six different states that show different behaviour in the network. Considering a 2D graphic object as a

parameter, the method calls to react upon the distance between nodes and draw them in the panel.

Drawing and calculations are done in different threads to show the behaviour of each node. Each state

in this method invokes other different methods of drawing and calculating.

The method searches for nodes located in the network and works on storing the

covered nodes in a new list, while deleting them from the initial list. and are

two different array lists of node type have been declared to distinguish the status of the node. Node

objects in the list represent nodes configured in the network, while nodes in the

list represent nodes removed from the network. The method uses a nested loop to call the

method and to compare the distance between two nodes in the network. uses a 2D

graphic object as a parameter to colour the coverage of nodes that are compared. State 2 in

invokes this method. In addition, this method is called in state 5 to remove any

covered nodes after the radius of nodes is modified in state 4.

The method executes a loop through a list of nodes comparing them against the

nodes that are evaluated. The function of this method adds all neighbours of a given node to its list of

neighbours which are declared as its attribute. It also works on defining these nodes by colouring all

nodes that will be added to the list of evaluated nodes using the 2D graphic object to fill the shapes. In

addition, these neighbours are filled concurrently due to the thread function used in the state. The

method is called from this method to determine the neighbour by returning a Boolean

value to the method, after calculating the distance and comparing it by the maximum distance. The

method is also called by method in state 3.

28

The method works upon the neighbour list of each node in the network. Using a combination

of if statement and loop as a nested loop, the method’s mission is to go through the neighbour list of

each node, to compare the neighbours with the evaluated node, to modify the radius of the evaluated

node and, in a way, to cover any gaps between itself and its neighbours. It invokes the method to

detect those gaps by comparing the distance in between nodes with the sum of the current radius of

both nodes. A 2D graphic object is used in this method to fill in nodes of the network that are repainted

by different values of its radius. Furthermore, the evaluated node is also filled by a different colour to

determine that is being weighed. The modification of the evaluated nodes depends on the number of

gaps used by the method, which calculates the function that the radius will be increased

by. The method uses a modified version of the function proposed in the Bell Labs [1],

where the radius of the node is modified by a factor of this function. The method used an

absolute value of the power of logarithm , as it shown in the following function. This is due to long

computation time occurs using the initial function. The method invokes the

method in state 4, after repainting the drawing area.

The method is the second method which depends on the neighbour list of each node

in the network. This method works on removing nodes that have empty list of neighbours in its attribute

from the node list and adding them to . It is invoked in state 3 and after calling state 4.

is a function called in state 5 to find any remaining gaps after the loop of evaluated nodes is

terminated and the size of some nodes is modified in state 4.

Calculating the distance between two nodes is done by the following formula:

√

This formula is used by three methods which return Boolean values, namely ,

and .

Furthermore, other functions and variables are used for measuring the total energy used by the network

and the average usage for each node. is the method which calculates the total

amount of energy, while the number of active and deactivated nodes in a network is the size of

and lists, respectively. The energy is measured by the radius of the node in relation to

the growth-rate function, as the energy unit is proportional to the value of the node’s radius.

29

The methods and are invoked in every state in the main

method and are constructing the 2D graphic object to draw the shapes of nodes. Using the constructor

attributes, they both draw a node object and its coverage in the network. However, the

method draws each node in both array lists of node objects, while the method draws the

coverage area of nodes in the array list only.

The constructor of class invokes node objects with default sizes and locations and maximum

distance between neighbour nodes. The locations of nodes to be drawn have a fix range in the drawing

area to ensure that each node is visible in the main interface window.

4.2 Implementation of cellular automata to W-SON

This code was implemented to create a self-configured and self-deployed wireless network. Wireless

base stations are modelled as nodes, where it is assumed the nodes are identical. Network protocol

unifies three different wireless networks: cellular systems, WMAM and WLAN. Thus, the nodes are

implemented as objects in the code. These objects simulate a number of nodes in an area of 190x240

pixels. In this model, the homogeneity of the nodes is a result of the assumption that these nodes are

wireless Bluetooth adapters connecting to different mobile devices, such as cellular mobile phone,

printers and laptops, to provide Internet access.

Technically, the modelling starts by creating a finite number of nodes which represent a possible

network. Each node is black in colour and it is encompassed by a green line which defines its area of

coverage. These nodes are created randomly to build an initial network which is the first state (state 1)

in the algorithm and initially stored in list. Theoretically however, this state sets-up the defaults

for the network where the real algorithm is starts in state 2.

In the second state (state 2), the wireless network deploys its nodes by a local function which works by

deactivating all nodes that can already be covered by other nodes in the area by the

method. The method is used for comparing one node against the others in

the list to check if it covers any nodes in the area. If the distance between two nodes is less than the

radius of the evaluated node, returns true values enabling the covered node to be de-

activated. The evaluated node appears in blue in the simulation, as shown in Figure 5. On the other hand

the covered node is showed in red before it gets de-activated. The coverage of the covered node is

removed, while the centre of it is coloured in red for the remainder of the simulation as it is moved to

30

list. The algorithm then switches to state 3, when the loop that evaluates nodes in the

list is terminated.

In cellular automata, neighbours of each cell in a grid are defined prior to the algorithm commencing.

However, in this simulation each cell defines its neighbour by searching for the nearest nodes in the

network. The algorithm starts by defining neighbours of each node and storing them in the neighbours

list as an attribute of nodes. This process is performed in state 3 by calling the

method as it depends on . If the distance between the evaluated node and another node

in the same node list is less than the maximum distance in the neighbourhood, then the node is added

to the evaluated nodes neighbour list. Again the evaluated node is shown in blue in the simulation,

while its neighbours appear in yellow as shown in Figure 6 . Once the algorithm has evaluated all active

nodes it moves to the next state.

Figure 5: Delete covered node

Figure 6: Defining neighbours of one node.

31

In state 4, the network starts to reconfigure itself by filling the gaps between the neighbours for each

node to maximise the range of network coverage, using the smallest possible number of nodes, in

addition to deactivating isolated nodes. The structure of the network is modified as each node resizes its

coverage area to reduce the gaps between nodes by implementing the method. This method

changes the radius of the evaluated node incrementally when it is proven that there is a gap between

the coverage of that node and its neighbour, as it increments the number of gaps returned from the

function. The function calculates the distance between the evaluated node and its

neighbours. If the distance is greater than the sum of the radius of the two nodes, then there is a gap

between nodes which is indicated by a true value being returned from the function. Furthermore, any

node that does not have any neighbours is deactivated, since in cellular automata each cell must have

defined neighbours and isolated nodes violating this rule. Nodes that are resized appear as orange

circles as they grow as shown in Figure 7. When all the nodes have been evaluated the algorithm

switches to state 5 to double check for any possible gaps that are left after state 4 and any overlapping

nodes.

In state 5 checks for any possible gaps left in the network after state 4 is terminated. State 5 uses the

method to check for any remaining gaps and to deactivate the covered

nodes. The algorithm switches between states 4 and 5 until all gaps are eliminated and all cover nodes

are de-activated, at which point the system has reached steady state. This is represent by state 6, where

the final state of the network is determined. All states repaint the background with the previous layout

of network nodes before the relevant function is called. All states use threading to calculate the distance

between nodes in order to distribute the computations and to display the behaviour of each node.

Figure 7: Growing nodes to fill the gaps.

32

Along with the simulation process the algorithm measures the number of nodes in the network as it

keeps track of the size of nodes in the list. In addition, it measures the deactivated nodes by calling the

size of list. The energy used to establish each node is also determined by measuring

the rate of growth of active nodes in the network. Summing these values leads to the total energy used

by the network before and after the self-deploying and self-configuring that is performed by

calling , which enables the program to check how much energy was used and how

much is saved by applying cellular automata. It also gives an indication of the average energy that each

node wastes after deactivation and resizing.

In the case study, the network depends on the feedback from mobiles connected to the nodes.

However, in the model, Bluetooth adapters spread through the floor randomly as nodes and devices

connected to them are represented by calculations of distance in the different methods and the

returning of Boolean values. The deactivated nodes in the model represent adapters removed from the

self-organised network. However, this still provides the local wireless service to its location.

Figure 8: State diagram.

33

Chapter 5: Results and evaluation

5 Results and evaluation

5.1 Results

The simulation was applied to a 190x240 pixel array where the radius of each node was 50 pixels and

the neighbourhood maximum distance was 55 pixels. The first stage of the simulation deployed the

network by deactivating the covered nodes. Once the covered nodes deactivated the network, the

system starts to reconfigure itself by modifying the coverage rate of each node in order to improve the

coverage of the whole network. The neighbour list of nodes is fixed during the simulation.

The simulation was executed four times for three different networks. The same methodology as the

initial case study was used with some modification such as the randomisation of node locations and the

energy consumed by a network. The function proposed by Bell Labs was also modified to produce faster

simulation. The initial function was modifying node coverage in very small intervals by using a power of

logarithm in the function. As result, the software enters in a very long loop when nodes being resized.

The case study used a regular grid of base stations. However, the grid of nodes is created by the network

when it defines neighbours and nodes. It is assumed that the adapters are applied geographically.

Therefore, four different versions of the same network were created in order to evaluate the real-life

simulator and the network.

All different networks were applied on the same size area. The neighbourhood distance defined the

closest neighbours of a node in network. Also the delaying time in threading was fixed to the different

network size. The results were gathered by comparing networks of different sizes and in which the four

different structures of the same network size were executed with the same delay time. To keep control

on node growth, the list of neighbours was not modified through the algorithm as that would have

resulted in a single large node. The output of the simulation was interesting for different structures of

the same number of nodes in a network. The three tables below represent results of 12 different runs of

the simulation.

34

25-node network

Structure Version 1 Version 2 Version 3

Version 4

Initial energy used

(unit of energy) 1250 1250 1250 1250

Number of nodes

left activated 15 15 14 14

Number of

deactivated nodes 10 10 11 11

Energy used by

reduced network 809.11 750 736.94 714.77

Average nodal

energy 53.94 50 52.63 51.05

Energy saved by

algorithm 440.88 500 513.05 535.22

Simulation time

(sec) 33.76 30.98 33.5 28.5

Visual spread

of nodes

Table 2: Four different structures of a 25-node network

35

55-node network

Structure Version 1 Version 2 Version 3

Version 4

Initial energy used (unit of energy)

2750 2750 2750 2750

Number of nodes left activated

24 22 20 24

Number of deactivated nodes

31 33 35 31

Energy used by reduced network

1229.55 1181 1059.11 1244.33

Average nodal energy

51.23 53.69 52.95 51.84

Energy saved by algorithm

1520.44 1568 1690.88 1505.66

Simulation time (sec)

95.5 105.4 89.1 89.4

Visual spread

of nodes

Table 3: Four different structures of a 55-node network

36

Table 4: Four different structures of a 75-node network

75-node network Structures Version 1 Version 2 Version 3 Version 4

Initial energy used

(unit of energy) 3750 3750 3750 3750

Number of nodes

left activated 27 25 25 21

Number of

deactivated nodes 48 50 50 54

Energy used by

reduced network 1431.27 1346.05 1323.89 1116.5

Average nodal

energy 53.01 53.84 52.95 53.16

Energy saved by

algorithm 2318.72 2403.94 2426.1 2633.49

Simulation time

(sec) 138.03 141 136.5 131.6

Visual spread

of nodes

37

5.2 Evaluation

An evaluation of the algorithm must include an explanation of the relevance of energy to the network

nodes. The aim of this simulation was to produce a self-organised network that can provide a best

coverage for a given area using the smallest possible number of nodes. These nodes are connected to

each other through a neighbourhood relationship. As the nodes of network are randomly distributed

there is the opportunity to evaluate the network with different range of nodes

5.2.1 Evaluating network structures with same number of nodes

Testing the simulation showed interesting results as the size of network was fixed to a certain number of

nodes. The range of active nodes and deactivated nodes remained approximately constant across

different simulations; however the different structures were of varying quality and performance. The

performance of a network was measured based on the connectivity of nodes and the extent of the area

that was covered by the network against the number of nodes and the amount of energy wasted by the

network.

5.2.1.1 Evaluation of the 25-node networks

The results of the simulations of the 25-node networks are given in Table 2. In version 1 the self-

deployment of the network reduced the network size by 40%, thus saving 440.88 units of energy out of

an initial energy of 1250. The spread of nodes provides a good coverage for the given area. However,

after the network was re-configured, the nodes became grouped into three separate groups which will

clearly affect the network performance. Some of the isolated nodes could remain active to cover more

of the area by increasing the neighbourhood distance. Some of the nodes were modified to increase the

level of coverage. However such modification was insufficient to meet the performance connectivity

condition.

Version 2 of the same network was poor in coverage and connectivity as the specific spread of network

nodes was not able to be modified by the automata algorithm. Again, the algorithm saved 40% of the

energy used as 9 out of 25 nodes were covered by other nodes in self-deployment, and one node was

completely isolated as it was not able to define it neighbour within its neighbourhood area. The nodes

were grouped into five disconnected groups where there are large gaps between nodes in the self-

configuring process. As a result, it was very difficult for an individual node to define its neighbours.

Increasing the neighbourhood distance was also ineffective in this case as it resulted in creating very

38

large nodes which used excessive energy. In summary, the randomisation of the network was poor and

thus it was difficult to improve the network coverage.

Version 3 of the 25-node network was the worst among the four versions, with a large area not covered

by any network nodes, although the algorithm was able to improve the coverage by resizing some

nodes. The main problem of this structure was the spread of nodes. The number of nodes could be

reduced more through node deactivation; however, although some active nodes were mostly covered

by their neighbours they could not be deactivated because the neighbour coverage did not reach the

centre of the node. An improved solution may have been to increase the neighbourhood distance and

redistribute the nodes. The algorithm deactivated 11 nodes and saved 513.05 units of energy but it was

able to maximise the coverage area due to the initial random structure of the network.

The final version of this network, version 4, produced an acceptable coverage of the area that can be

described as a good coverage. The distribution of nodes is very good as the network covers a wide range

of the area. The neighbourhood distance was small however, which resulted in the nodes being grouped

nodes into 2 disconnected groups, as was seen in version 1. The networking saved 42.8% of the total

energy used and each node used one extra unit of energy on average. The network used 14 nodes to

provide coverage as 11 nodes were inactivated. The modified nodes helped the network to reduce the

gaps, but the 2 nodal groups remained disconnected.

The different versions of the 25-node network showed an ability of 25% to provide a good network with

good coverage using less energy and fewer nodes. In half of the cases it was seen that the random

structure was not able to distribute the nodes well while the other cases showed when the network was

well distributed the performance was able to be improved by increasing the neighbourhood distance.

Dis-connectivity and grouping of a collection of nodes separately was a serious problem in this network

as one out of the four versions provided a good coverage with a 90% nodal connectivity. Increasing the

neighbourhood distance by a small amount will allow the network to define more neighbours in its list

thus reducing the large gaps that are present in the initial network. The average execution time for this

network size was 33.66 seconds.

5.2.1.2 Evaluation of the 55-node networks

The results of the simulations of the 55-node networks are given in Table 3, where the area and

neighbourhood distance are the same as for the 25-node networks of the previous section.

39

In version 1 of this network 55% of the nodes were deactivated due to overlapping coverage and the

distribution of the nodes was oval. Most of the given area was covered by the network but the network

was divided into three disconnected groups. Gaps between the three groups were small and they were

reduced in the self-configuring stage. The shortness of neighbourhood distance generated dis-

connectivity between nodes in the network. However, increasing the neighbourhood distance would not

have been efficient as it would deactivate more nodes thus reducing the coverage area. By running 24

nodes, the network saves approximately 55% of the total network usage. A sensitive solution to improve

the network performance would be to increase by small intervals to avoid further issues such as large

growth of some nodes.

In version 2 of the network the nodal distribution provided favourable performance as the network

covered 80% of the area and the algorithm was able to save 57% of the initial network energy.

Compared to version 1, version 2 used fewer nodes (22 versus 24) and provided a better coverage than

the first version. A drawback of this network, however, was that it contained disconnected nodal groups,

which was a result of nodal deactivation. Subsequent network modification did not help to reduce the

gap between the groups as there were no nodes of either group could define a neighbour in the other

group. Another issue in this version was that it was possible to save more energy by deactivating

additional nodes. In the deployment, as some important nodes were deactivated, other nodes provided

most of the network coverage. However, the simulation was not able to define the most covered active

nodes, which were supposed to be deactivated, because their centre was not practically covered.

Considering the energy saved and that nodes remained active after self-configuring, this network

provided good coverage using a small number of nodes.

Version 3 showed even better performance than the previous two versions, since it did not suffer from

the grouping issue of the previous versions, thus meeting the connectivity condition as well as providing

90% network coverage. The network used 20 nodes after self-configuring which is fewer than those

used in the previous two versions. Each node used, on average, almost 53 units of energy, saving in total

61.45% of the initial network energy. The distribution of nodes was not a serious problem in this version

however the network had a single isolated node which was deactivated once the neighbours were

defined. The visual depiction of this network version displayed in the final row of the table illustrates a

previously unseen problem as the number of nodes is increased. One out of the 27 nodes was

deactivated during the self-configuring process, where its coverage was mostly covered by other nodes,

however the centre of that specific node was not in covered by any of its neighbours leading to this

40

node being kept active. In this case the algorithm was not able to identify this problem because the

condition for deactivation the node was never met.

Finally, version 4 of this network has 24 active nodes after self-deploying and self-configuring. The

shortness of neighbourhood distance again affected the network. The overall performance of this

network was good with 90% network connectivity and area coverage conditions were met.

Furthermore, the network saved about 54.75% of the initial energy used in the network. The network

had two neighbour nodes that were grouped far from the rest of the network, resulting in disconnected

network group. The gap between the two groups was very small which could be covered by sensitive

modification of neighbourhood. In this version, at least one out of the total number of active nodes in

the network could be deactivated if the network recognised that its coverage area is mostly covered by

neighbours to that node.

The improvement for this network size was clear and the randomised nodal structure did not cause any

significant problems. The connectivity condition was met by only 25% of the cases in this sample,

however a good improvement is seen in network coverage with 80% to 90% network coverage for 75%

of the cases in this sample. In the other hand the connectivity issue was reduced by 75% in the 55 node

networks as it was only 25% in the 25 node networks. However, two new problems appeared in the 55

node networks. The first problem was deactivation of covered nodes, which seems to be important in

the self-configuring stage to improve the connectivity problem. The second problem was that the

network was not able to distinguish whether the node status is already mostly covered by that of other

nodes since the node under scrutiny cannot be deactivated as long as the coverage of other nodes does

not reach its centre. The average execution time for this network size was 79.1 seconds.

5.2.1.3 Evaluation of the 75-node networks

The results of the simulations of the 75-node networks are given in Table 4, where the network energy

increased to 3750 units. It can be seen from the table that, for each version, the network deactivated,

on average, 50 nodes. Version 1 of this network produced a good distribution of nodes with more than

90% network coverage. However, the gap between the nodes in the middle of the network could not be

covered completely. Self-configuring helped to reduce this gap to the minimum as nodes in this area

were connected. A real improvement in connectivity can be seen in this version as the network was

100% interconnected. Self-deployment in the network resulted in a deactivation of 48 of the 75 nodes.

In terms of energy, the network saved more than 61% of the initial network energy usage.

41

Version 2 deployed 25 out of 75 network nodes. The connectivity condition was met while a very good

coverage was provided to the area. Each node used, on average, 53.84 units of energy, similar to the

energy usage in version 1. As a result, node deactivation was improved in this version. In total the

network saved approximately 64.1% of the initial energy after self-configuration and self-deployment.

The gaps in the network were reduced during self-configuration, with only small gaps in coverage

remaining between the nodes. Two out 25 nodes were mostly covered by other nodes.

Version 3 showed very similar performance to that of version 2, where the network has comparable

nodal usage and energy savings after deployment and configuration. However, the nodal distribution did

not provide good network coverage of network as most of the nodes were clustered in the bottom right

quadrant of the network and most of them were deactivated due to overlapping coverage.

In version 4, the network had the smallest number of nodes after deployment and configuration, which

led to the largest energy saving, being reduced from 3750 to 1116.7 units. Despite the modifications

made to some nodes during the self-configuring process, the network coverage did not improve

performance. Disconnected groups are shown in this version as a result of poor nodal distribution.

When compared to the initial number of nodes and other versions of the network, version 4 has the

worse coverage among the other versions of the network. In this case the problem is mainly the random

distribution of nodes.

When the number of network nodes was increased to 75, 75% of the samples showed the problem of

dis-connectivity. An improvement of 90% in area coverage is shown in three out four versions. On the

other hand, the network did not show any improvement to solving the recognition of mostly covered

nodes. The network used 24 nodes on average, with two-thirds of the nodes being deactivated in all

instances, indicating that the network reached the saturation level of nodes.

42

0

10

20

30

40

50

60

70

80

90

100

25 nodes 55 nodes 75 nodes

pe

rce

nta

ge %

network size

Average network performance

No.ActiveNodes

Connectivity

energy saved

coverage

5.2.2 Evaluating network and time execution over the increasing of nodes

In this simulation it was expected that increasing the number of nodes would show a better

performance in self-organised network in terms of area coverage, interconnectivity of nodes, number of

nodes after network self-deployment and self-configuration and finally the energy saved by the self-

organised network. This expectation was correct, as demonstrated in Figure 9, which depicts the

average performance of each characteristic for the various networks. On the other hand, the increase in

nodal number showed further issues in the network that the simulation could not handle properly. The

results that are summarised in the three tables demonstrate that when 55 and 75 nodes were used the

simulation provided a better nodal distribution which resulted in good network coverage. However, the

network was saturated in both cases, as only around 20-30 nodes remained active after self-deployment

and self-configuration. This saturation can be seen most clearly in the case of 75 nodes when only one

third of the total number of nodes remained active. As a result, the saved energy that was achieved for

the different network structures was mostly gained simply as a result of the self-deployment process for

the covered nodes.

The area covered by the network increased by 50% in the 75 node networks compared to the 25 node

networks, which indicates that the improvement is consequence of good nodal distribution in addition

to efficient self-configuration. The network connectivity, in which the nodes in the network build a single

large group covering the area, was very poor in the 25 node networks but was improved in the 55 node

networks as the number of isolated nodal groups was reduced when the number of nodes was

Figure 9 Average performance of each network

43

increased. Furthermore, the large gaps that were seen between the nodal groups in the 25 node

networks were reduced as the network size increased.

Over-coverage for the given area was seen when a large number of nodes were deployed to improve

the network coverage. The self-organised network was not able to identify nodes that were mostly

covered by other nodes, and which therefore should have been deactivated. As a result the network was

not able to save the energy of this node whilst maintaining network coverage. Moreover, in some cases,

deactivating the covered node in the self-deployment process deactivated nodes that were able to solve

the dis-connectivity problem in the self-configuration process.

The execution time of this simulation almost tripled in the 55-node networks compared to the 25-node

networks, while, on average, it was almost 4.5 times in the 75-node networks compared to the 25-node

networks (Figure 10). Because of the saturation in the number of nodes in the 75-node networks, the

increase in time execution in these networks (compared to the 50-node networks) was notably smaller

than that observed when comparing the execution times between the 55- and 25-nodes networks. The

self-deployment of a network is affected by the number of nodes, as the simulation has to compare

each node in the network against the other nodes looking for any covered ones. In self-configuration of

a network, however, a large amount of nodes will be deactivated and removed from the active list; as a

result, the simulation is working only on the active node. The time of execution does not increase at the

same rate as the number of nodes, because of the looping done in the self-deployment process,

showing the behaviour of each node of the network. A drawback of this simulation in relation to

execution time calculated is that the software starts counting when the ‘start’ button is pressed until the

last state of the simulation is terminated, including the delay that occurs before the ‘continue’ button is

0

50

100

150

25 55 75

Tim

e in

se

con

ds

Number of Nodes

Execution time

Execution time

Figure 10: Execution time over number of nodes.

44

pressed. Therefore, the time keeps counting even when the ‘continue’ button is pressed after one of the

middle states is completed. The algorithm used in simulation was not efficient as it was evaluating one

node at a time. As the number of nodes increases the execution time of self-deploying process

increases, thus paralleling this part of the code would improve the execution time of the simulation.

5.3 Further work

The simulation showed an improvement of performance, although this simulation could be improved to

show a better result in the network performance. One development could consider the deactivated

node list in the self-configuring process, where the simulation can define possible neighbours after cell

modification of the active node. As a result, an improvement in network connectivity may be possible.

Another improvement could be made if the neighbourhood distance was increased for the case that the

number of nodes used in the initial network was small. Increasing the distance allows an isolated

network to define neighbours in the self-configuring process. Moreover, it is possible to identify the

mostly measured nodes by calculating the mid-point between the centres of two nodes. As a result, the

network could be improved when the number of nodes is reduced. The execution time of the

simulation could be improved, if parallel computing of each node was applied using multiprocessing

strategies to evaluate each node in parallel to drawing of nodes.

This case study was based on fixing the neighbour list, the area of each node and the number of nodes.

More cases could be considered by changing the radius of the initial nodes or by updating the

neighbours of each node, by limiting the growth rate of each modified node to a fixed value.

45

Bibliography

Bibliography 1. Mullany FJ, Ho LTW, Samuel LG and Claussen H. Self-deployment, self-configuration: critical future

paradigms for wireless access networks.[ed.] Smirnov M. Autonomic Communication. Berlin:

Springer/Heidelberg, 2005, Vol.3457, pp. 58-68.

2. Hopcroft J, Motwani R and Ullman JD. Introduction to automata theory, languages, and computation.

3. s.l. : Pearson/Addison Wesley, 2007.

3. Dowman M. Unsupervised learning of probabilistic automata for language modelling. Proceedings of

Intelligent Systems and Applications 2000, Wetaskiwin, Alberta, Canada: ICSC Academic Press. [Online]

2006. [Cited: 29 01 2011.]

http://www.ling.ed.ac.uk/~mdowman/UnsupervisedLearningOfProbabilisticAutomataForLanguageMod

elling.pdf.

4. Stoelinga M. An introduction to probabilistic automata. EATCS Bulletin, no. 78, 2002. [Online] 2002.

[Cited: 26 01 2011.] http://wwwhome.cs.utwente.nl/~marielle/papers/pa.pdf .

5. Brushe GD, Mahony RE and Moore JB. A forward backward algorithm for maximum likelihood state

and sequence estimation. Proceedings of ISSPA 96, Gold Coast, Australia, vol. 1, pp. 224-227, 1996.

[online] 1996. [Cited 13 02 2011] http://users.cecs.anu.edu.au/~john/papers/PROC/067.PDF .

6. Hoogeboom HJ and Engelfriet. Pushdown automata. In: Formal languages and applications. (Eds:

Martín-Vide C, Mitrana V and PăunG). Studies in fuzziness and soft computing, vol. 148, pp. 117,138,

2004 (Berlin: Springer).

7. Schwoon S. Model-checking pushdown systems. PhD Thesis, Computer Science Institute, Tecnical

University of Munich, Munich, Germany. [Online] 2006. [Cited: 15 03 2011.] http://tumb1.biblio.tu-

muenchen.de/publ/diss/in/2002/schwoon.pdf.

8. Bouajjani A, Espar J and Maler O. Reachability analysis of pushdown automata: application to model

checking. Proceedings of CONCUR 97, LNCS 1243, Warsaw (Poland), June 1997. [Online] 1997. [Cited: 16

02 2011.] http://www-verimag.imag.fr/~maler/Papers/pda.pdf.

9. Alur R and Drill DL. A Theory of timed automata. Theoretical Computer Science, vol. 126, pp. 183-235,

1994. [Online] 1994. [Cited: 27 01 2011.] http://www.cs.aau.dk/~srba/courses/MCS-07/TA.pdf.

10. Bouyer P. An introduction to timed automata. Technical Report, LSV – CNRS & ENS de Cachan,

Cachan, France. [Online] 2005. [Cited: 8 03 2011.] http://www.lsv.ens-

cachan.fr/Publis/PAPERS/PDF/bouyer-etr05.pdf.

46

11. Abdeddaım Y, Asarin E and Maler O. Scheduling with timed automata. Theoretical Computer

Science, vol. 354 (2), pp. 272-300, 2006. [Online] 2005. [Cited: 2 02 2011.] http://www-

verimag.imag.fr/~maler/Papers/schedule-tcs.pdf.

12. Gutowitz H. Cellular automata: theory and experiment. s.l. : The MIT Press, 1991.

13. Schiff JL. Cellular automata: a discrete view of the world. Wiley-Interscience series in discrete

mathematics and optimization, vol. 45, 2008, s.l. : Wiley-Interscience.

14. Ganguly N, Sikdar BK, Deutsch A, Geoffrey Canright and Chaudhuri PP. A survey on cellular

automata. Technical Report, Centre for High Performance Computing, Dresden University of Technology,

Dresden, Germany. [Online] 2003. [Cited: 4 04 2011.]

http://www.cs.unibo.it/bison/publications/CAsurvey.pdf.

15. Li W and Packard N. The structure of the elementary cellular automata rule space. Complex Systems,

vol. 4, pp. 281-297, 1990. [Online] 1990. [Cited: 8 04 2011.]

http://citeseerx.ist.psu.edu/viewdoc/download?doi=10.1.1.15.1354&rep=rep1&type=pdf.

16. Marcou O, El Yacoubi S and Chopard B. A Bi-fluid Lattice Boltzmann Model for Water Flow in an

Irrigation Channel. [ed.] El Yacoubi S, Chopard B and Bandini S. Cellular Automata. s.l. : Springer Berlin /

Heidelberg, 2006, Vol. 4173 of Lecture notes in computer science LNCS sublibrary: Theoretical computer

science and general issues, pp. 373-382.

17. Chopard B and Droz M. Cellular automata modeling of physical systems. s.l. : Cambridge University

Press, 1998.

18. Zigangirov KS. Introduction to cellular mobile radio communication. In: Theory of code division

multiple access communication. s.l. : Institute of Electrical and Electronics Engineers.[Online] 2004.

[Cited: 25 03 2011.] http://media.wiley.com/product_data/excerpt/24/04714571/0471457124.pdf.

19. Garg VK. Wireless Communications Networking. s.l. : Morgan Kaufmann, 2007.

20. Rackley S. Wireless networking technology: from principles to successful implementation. s.l. :

Elsevier, 2007.

21. Mudd S, Garcia JB and Fernández JM . Wireless network structure - v1.3. Technical Report. [Online]

2002. [Cited: 13 03 2011.] http://www.wl0.org/~sjmudd/wireless/network-structure/english/article.pdf.

22. Hossain E. Heterogeneous wireless access networks: Architectures and Protocols. 4. s.l. : Springer,

2008, Vol. 6.

23. Prehofer C and Bettstetter C. Advances in self-organizing networks, self-organization in

communication network: principles and design paradigms. IEEE Communications Magazine, July 2005,

pp.78-85, 2005. [Online] 2005. [Cited: 10 03 2011.]

http://www.cis.udel.edu/~yackoski/firefly/01470824.pdf.

47

24. Baliosian J, Oliver H, Devitt A, Sailhan F, Salamanca E, Danev B and Parr G. Self-configuration for

radio accessnNetworks. Proceedings of the Seventh IEEE International Workshop on Policies for

Distributed Systems and Networks (POLICY'06). [Online] 2006. [Cited: 20 03 2011.]

http://jauu.net/var/print-queue/01631159.pdf.

25. Lu H. Wireless ad-hoc networks. Teaching File, 2004. [Online]. [Cited: 10 04 2011.]

http://www.cs.rutgers.edu/~rmartin/teaching/fall04/cs552/papers/008.pdf.

48

Appendix A: Personal reflection

Personal reflection This piece of work was the biggest report I have written as an undergraduate student. In this report I

explored my understanding of the three-year course in Computer Science. I was inspired by practical

problem solving model in the second year, where I first studied the automata. By that time only a simple

idea of the automata was given. In this year I was very interested to learn more about automata. In this

report I studied automata in reasonable depth.

My passion to learn and improve what I have learned has always been my motivation. Cellular automata

were introduced in semester one of this year, when I was proposing for the final-year project. I had to

make a full study of this type of automat, in addition to its relation to physical system. In this report, I

studied different research areas such as the communication networks and aggregation problems in

order to understand how these problems have been solved by automata. This was a challenge to me to

demonstrate the knowledge I acquired during the past three years of the undergraduate course and

apply it in a project with this amount of data

Planning and time management has always been a serious problem for me with regard to completing

my work. Although I got behind my schedule by two week, I was proud to complete the project a week

before the deadline, as I had planned from the beginning so that I had time to revise and proof read the

report. Literature searching and reading was the most difficult part which took me rather a lot of time to

complete and showed to me that my lack of reading resulted in a delay in the plan. I realised that there

should always be an alternative plan, which if had it in the first place; I would have saved a lot of time

searching over new plans.

If I had more time for computer programming, I would have applied some of the solutions, I mentioned

under the section Further Work in Chapter 5. I would have considered the deactivated node list to

improve the performance of nodes and to show how the deactivated node can be added to the network

through a self-configuration process.

49

Appendix B: Programming code

Programming code

Programming code is attached as CD.