UNIVERSITY OF CINCINNATI
12/10/2008
Date:___________________
Balakumar Rajendran
I, _________________________________________________________,
hereby submit this work as part of the requirements for the degree of:
Master of Science
in:
Computer Engineering
It is entitled:
3D Agent Based Model of Cell Growth
This work and its defense approved by:
Dr. Carla Purdy
Chair: _______________________________
Dr. Daria Narmoneva
_______________________________
Dr. Ali Minai
_______________________________
_______________________________
_______________________________
3D Agent Based Model of Cell Growth
A thesis submitted to the
Division of Research and Advanced Studies
of the
University of Cincinnati
in partial fulfillment of the
requirements for the degree of
MASTER OF SCIENCE
in the Department of Electrical and Computer Engineering
of the College of Engineering
December, 2008
by
Balakumar Rajendran
B.E. in Electronics and Communication Engineering
Anna University, Chennai, India
Thesis Advisor and Committee Chair: Dr. Carla Purdy
ABSTRACT
This research aims at modeling the cell cycle regulation as a three dimensional Agent
Based Model. Agent Based Modeling (ABM) is a computational model for simulating
autonomous entities in a network. ABM is emerging as a powerful tool in the field of systems
biology. ABM is preferred over traditional modeling methods, as it takes the spatial dynamics of
the interactions into account. The system is modeled as a collection of autonomous decision
making entities called agents. Each of these agents has its own set of characteristics and
behavioral rules that are highly adaptive to its surrounding environment. Since the agents have
their own sets of characteristics and rules, they can be implemented using the Object Oriented
Programming (OOP) concept. OOP is a powerful programming technique that can be used to
model and design applications effectively. Previously our lab implemented an ABM model of the
phage lambda virus and used this model to study the behavior of phage lambda under various
conditions. Building on our experience, we have developed a more complex agent based model
in a Java based ABM platform. The cell cycle model is modeled in MASON, a very robust and
efficient ABM platform that supports strong 3D visualization and parallelization. The model
shows how the cells interact among each other at an intercellular level. The stages in the cell
cycle are implemented and the characteristics of cell growth are studied. This particular model
has also been extended to simulate a wound condition and its growth characteristics are again
observed. The model is run for certain base parameter values and the system can be simulated for
other conditions by changing these parameters. Tissue Engineering is an important and growing
field, and computational models such as the one developed in this thesis can be very useful tools
for biologists and tissue engineers.
iii
iv
Acknowledgments
First of all, I would like to thank my research advisor, Dr. Carla Purdy who has been with
me through every step of my research. I am also deeply indebted and grateful to my advisor for
her constant guidance and support. Her patience and perseverance has helped me a lot to stay
focused on this research. Her suggestions and remarks during the difficult phase of this research
were like the myriad stars of a summer night. I also thank her for giving me an opportunity to
work under her guidance.
I would like to extend my gratitude to Dr. Ali Minai and Dr. Daria Narmoneva, my
committee members for their presence in my Master’s thesis defense. I would also like to thank
them for their valuable suggestions and feedbacks.
I would also like to personally thank Swathi Balaji and Varun Krishnamoorthy, members
of the Vascular Tissue and Cellular Engineering lab for their time to review the model and their
suggestions to make the model better.
My acknowledgment would not be complete had I not mentioned my friends, Chandru,
Divya, Mani, Sid and Suresh who go with the proverb “A friend in need is a friend indeed”.
They have always been with me during the ups and downs. Special thanks to all burnet and
riddle boys and girls for making the stay in UC a very memorable one.
I am dedicating this thesis to my mother and father, for without their guidance, support
and inspiration the roads that I took so far would have been much tougher.
v
Contents
1. Introduction
1
1.1. Motivation ........................................................................................................................ 1
1.2. Advantages of in silico over in vitro ................................................................................ 1
1.3. Systems Biology............................................................................................................... 2
1.4. Research Goals ................................................................................................................. 2
1.5. Organization of the Thesis ............................................................................................... 3
2. Background
5
2.1 Introduction to Agent Based Modeling (ABM) ................................................................... 5
2.2 Why Agent Based Modeling? .............................................................................................. 6
2.2.1 Definition of an Agent ................................................................................................ 7
2.2.2 Traditional Modeling Methods and Their Disadvantages .......................................... 8
2.2.3. Advantages of ABM ................................................................................................ 10
2.3 Comparison of Various ABM Tools .................................................................................. 11
2.4 MASON: The ABM Tool of Choice .................................................................................. 12
2.4.1 Features of MASON ................................................................................................. 14
2.4.2 MASON Architecture ............................................................................................... 14
vi
2.5 Case Study: The Skin Cell Cycle ....................................................................................... 17
2.6 Background of the Biological Aspects of the Model ......................................................... 20
3. Implementation
22
3.1. Initial Model Conditions and Basic Model Structure .................................................... 22
3.2. Rule-based Modeling ..................................................................................................... 23
3.3. Modeled Cell Types ....................................................................................................... 24
3.4. Cell Cycle Process .......................................................................................................... 25
3.5. Functioning of the Cell Cycle from Programming Point of View ................................. 32
3.6. Flowchart for the Agent Based Model ........................................................................... 33
3.7. Composition of the Environments in the Model ............................................................ 34
3.8. Agents Modeled in the System and Their Rules ............................................................ 34
3.9. Unified Modeling Language Diagrams ............................................................................ 37
3.9.1 Entity Relationship Diagram ................................................................................ 37
3.9.2 Class-Responsibility-Collaboration Cards and Class Diagrams .......................... 38
3.9.3 Agent UML........................................................................................................... 43
3.10. Data Structure in the Code ............................................................................................. 46
4. Results
48
4.1 Simulation Arrangement ................................................................................................ 48
4.2 Parameters Involved in the Simulation .......................................................................... 49
4.3 Simulation Results.......................................................................................................... 52
4.4 Simulation of Wound Condition .................................................................................... 60
4.5 Variation of Simulation Parameters ............................................................................... 65
vii
4.6 Improvements Suggested by Biologists .........................................................................65
4.7 Performance Graph ....................................................................................................... 66
5. Conclusions and Future Work
68
5.1. Conclusions ....................................................................................................................... 68
5.2. Future Work ...................................................................................................................... 69
5.3. Presentation Based on this Work ...................................................................................... 71
Bibliography
72
Appendix: 3D Agent Based Model of Cell Growth
77
viii
List of Figures
2.1
Block Diagram of an Agent ……..……………………………………………………… 8
2.2
MASON Model Checkpoint and Recovery Design [22] ………………………….…… 13
2.3
MASON Architecture ……………..…………………………………………………… 16
2.4
Important Fields in the Model in MASON ..................................................................... 17
3.1
Interphase and Mitosis Phase Flow …...…………..……………………………………. 26
3.2
Cell Cycle Process ……........…………………………………..………………………. 26
3.3
Cell Activity in G1 Subphase ………………..………………………………………… 27
3.4
Cell Activity in S Subphase ……….……………..…………………………………….. 28
3.5
Cell Activity in M Phase …….....………………………………………………………. 29
3.6
Flowchart for the Agent Based Model …………………………………………………. 33
3.7
Entity Relationship Diagram of the Model …………………………………………….. 38
3.8(a) CRC Card for the CELL, STATIONARY and MOBILE Classes ………………….….. 39
3.8(b) CRC Cards for Substrate, Cell Monomer, Monomer and Dimer Classes …..…………. 40
3.8(c) CRC Cards for Cell Dimer, Mitosis Monomer and Quiescent Classes ....………..……. 41
3.9(a) Class Diagrams …………………………………………………....…………………… 42
3.9(b) Class Diagrams for Mitosis Monomer and Quiescent Classes ....……………………… 43
ix
3.10
Class Diagrams for Substrate Class Using AUML …………..………………………… 44
3.11
Class Diagrams for Other Classes Using AUML .……………...…………….………... 45
4.1
Parameters Involved in the Simulation ……...…………………………………………. 49
4.2
Snapshot of the Console Window …………………………………………….……....... 50
4.3
Snapshot of the Initial Condition of the Simulation …......…………………………….. 53
4.4
Snapshot of Agents in M Phase ....................................................................................... 54
4.5
Snapshot of Agents in G1-S-G2-M Phase and M Phase-G1 Subphase ….….…..……... 55
4.6
Snapshot of Agent in G0 Subphase ……………………………………….…………… 56
4.7
Snapshot of the Model at an Intermediate Level …..………………….…………….…. 57
4.8
Snapshot of the Model Towards the End ......................................................................... 57
4.9
Cell Growth Characteristics with Base Parameters ......................................................... 59
4.10
Snapshot When Cells Are Deleted ................................................................................... 60
4.11(a) Snapshot Taken at 29th Iteration ...................................................................................... 61
4.11(b) Snapshot Taken at 30th Iteration ...................................................................................... 61
4.11(c) Snapshot Taken at 32nd Iteration ...................................................................................... 62
4.11(d) Snapshot Taken at 37th Iteration ...................................................................................... 62
4.11(e) Snapshot Taken at 42nd Iteration ...................................................................................... 62
4.11(f) Snapshot Taken at 47th Iteration ...................................................................................... 62
4.11(g) Snapshot Taken at 51st Iteration ....................................................................................... 63
4.12
Cell Growth Characteristics When Wound Occurred ...................................................... 64
4.13
Cell Growth Characteristics After Stabilization .............................................................. 64
4.14
Performance Graph of the System ................................................................................... 67
x
List of Tables
2.1
Comparison of Agent Based Model Tools ....................................................................... 11
3.1
Tabulation of Rules Undertaken in Cell Cycle ................................................................ 30
4.1
Base Parameter Values Considered for the Simulation ................................................... 51
4.2
Size of the Agents Modeled in the System ...................................................................... 52
4.3
Number of Agents During the Simulation ....................................................................... 58
xi
Chapter 1
Introduction
Chapter 1 begins with the motivation that led to this research. The chapter covers the factors that
led to the in silico approach over in vitro. The research goals have also been defined.
1.1 Motivation
The main motivation behind the thesis is to provide biologists computational support for
experiments which up until now must be performed exclusively in vitro. Performing many
experiments in silico is much faster and has the potential to aid the experimenter in deciding
which experiments to conduct in the lab, thus potentially saving time and expensive resources.
And some biological simulations can potentially be made even faster in silico by employing
parallelization of the simulations. But the value of the simulations depends a great deal on how
accurate the underlying models can be made.
1.2 Advantages of in silico Over in vitro
The main advantages of in silico experimentation over in vitro experimentation are as follows:
1. in vitro experiments take a long time when compared to the simulations that are carried
out in silico. It will be easier to collect the in silico results and analyze them.
1
2. The resources needed to perform an in vitro experiment will definitely be more when
compared to in silico. In addition, different in vitro experiments will need different
materials and resources, while all the simulations can be done on the same computer.
1.3 Systems Biology
Systems biology is an emergent field that aims at system-level understanding of biological
systems [1]. One of the main ideas behind systems biology is to develop computational
capabilities to understand complex biological systems. Other goals related to systems biology
would be to identify protein machines, explore functions in microbial communities and also
characterize gene regulatory systems. Here in this thesis, a systems biology approach is adopted
to model a cell cycle system.
1.4 Research Goals
The goals of this research are as follows:
1. To design an Agent Based Model (ABM) that simulates the cell cycle regulation
behavior.
2. To choose the correct agent based model platform to easily enable further development of
the model described here. For example, only certain agent based models support
parallelism and 3D visualization.
3. To implement the cell cycle regulation process in the model chosen.
4. To test the model for a range of cases and make sure the model is stable.
2
5. To analyze the results obtained from the simulation and compare them with in vitro
results.
1.5 Organization of the Thesis
The thesis is organized in five chapters.
Chapter 2 focuses on the background of the research. It starts off with a brief explanation about
Agent Based Modeling and its advantages, along with the reason for choosing this type of
modeling over other traditional types of modeling. Various ABM modeling languages and the
reason why MASON is chosen over other languages are discussed. The MASON model’s
architecture has been explained briefly. This chapter also gives a brief overview of the cell cycle
regulation process.
Chapter 3 explains in detail the implementation of the cell cycle regulatory process. A better
understanding of the cell cycle regulatory process is given with the help of a flowchart and
pathway diagrams. Unified Modeling Language has been used for better understanding as it
gives a graphical representation of the models developed in software systems.
Chapter 4 shows the results that are obtained from the simulation of the model. The model has
been simulated for the general case, i.e., the normal cell cycle process. Going a step further, the
model also shows results for a wound condition.
3
Chapter 5 draws the conclusion for the thesis and discusses the future scope for research in this
field.
4
Chapter 2
Background
In Chapter 2 we provide an introduction to Agent Based Modeling (ABM) and its advantages.
We discuss the various ABM tools available and explain why we have chosen to implement this
project in the MASON system. We also describe the case study chosen for this work, a model of
the cell cycle.
2.1 Introduction to Agent Based Modeling (ABM)
Agent Based Modeling (ABM) is a computational model for simulating autonomous entities in a
network. ABM is a powerful simulation modeling technique that has been in use in a lot of
applications [2]. It combines elements of game theory [3], complex systems [4], emergence [5],
computational sociology [6], multi agent systems [7], and evolutionary programming [8]. In
ABM, a system is modeled as a collection of autonomous decision-making entities called agents.
These agents are highly adaptive to their surrounding environment and can react to the
environmental conditions. Repetitive complex reactions between the agents are a feature of
ABM, and these interactions mainly rely on the power of today’s multi core processor computers
[9] [10]. ABM consists of a system of agents and the relationships between them. A simple ABM
can exhibit complex behavior patterns [11] and provide valuable information about the system
that it emulates. In addition, agents may be capable of evolving, allowing unanticipated
5
behaviors to emerge. Sophisticated ABM sometimes incorporates neural networks, evolutionary
algorithms, or other learning techniques to allow realistic learning and adaptation.
In ABM, the agents interact with each other and each of the agents has a specific set of
characteristics and rules. Object Oriented Programming (OOP) [12] can be used to model the
agents as objects. OOP is a programming paradigm that uses objects and their interactions to
design applications and computer programs.
Agent Based Modeling is known by many names. Agent based Modeling (ABM), Agent Based
Systems (ABS) and Individual Based Modeling (IBM) are all widely used [13], but Agent Based
Modeling is the term that is used throughout the thesis. ABM follows a bottom-up approach
where the system interactions emerge from local interactions among components. All the agents
in the system are modeled within a region called an environment. The environment is the space
where all the agents of the system will interact with each other. The system does not have any
kind of overall centralized monitoring system that controls all the agents. As mentioned earlier in
this section, the agents have the capability to interact with other agents.
2.2 Why Agent Based Modeling?
ABM models a system composed of multiple interacting intelligent agents. To get a better
understanding, the following sections explain briefly on what an agent is, its advantages and the
reason for choosing ABM over other traditional methods.
6
2.2.1 Definition of an Agent
An agent can be described as a discrete entity with its own set of behaviors and goals. It can also
be described as autonomous, meaning the agent has the capability to change its behaviors and
goals depending on the conditions surrounding it. Certain modelers consider any type of
independent component to be an agent [14]. The agent’s behavior can vary from primitive
reactive decision rules to complex adaptive intelligence. The agent should contain a set of rules
for its basic behavior and it should have a set of rules with which it can adapt itself to its
surroundings [15].
The following are some of the characteristics that an agent would be expected to have:
1. An agent is a discrete individual with a set of characteristics and rules.
2. Agents should be self contained.
3. Each agent will have certain protocols with which it can establish communication
with other agents.
4. Each agent has its own goals which it has to fulfill.
5. Each agent is flexible, meaning it can also change its rules depending on its
surroundings.
All of the above characteristics can be clearly understood from the diagram in Figure 2.1.
7
Figure 2.1: Block Diagram of an Agent [13]
2.2.2 Traditional Modeling Methods and Their Disadvantages
In this section, we discuss why Agent Based Modeling is preferred over the traditional methods
that are used to model systems. Previously, biological systems have been modeled using such
traditional methods as Ordinary Differential Equations (ODE), Partial Differential Equations
(PDE), Stochastic Differential Equations (SDE), Petri Nets [16] and Pi-Calculus [17]. These
methods are in general referred to as Equation Based Modeling (EBM) [18]. Both ABM and
EBM share some common properties, but at the same time they differ from each other because
the fundamental entities that they model and the level at which each of these are modeled are
different.
The fundamental difference between ABM and EBM is in the relationship on which each focuses
attention. EBM, as the name indicates, models the system with a set of equations that expresses
the relationships among the characteristics of interest. These equations may be algebraic, and
these can exhibit variability over time in the case of ODE and can show variability over both
8
time and space in the case of PDE. ABM, on the other hand, does not model the system based on
equations, but instead models the system’s behavior through which the agents interact [18]. In
most cases, the traditional methods tend to aggregate the values when modeling the system. This
aggregation of the values might not be precise, eventually leading to erroneous results. Hence,
ABM is preferred.
Differential equations can model biological systems only to a certain extent. When a biological
system exhibits both discrete and continuous models, differential equations cannot be used to
model the system in an efficient manner. Differential equations can be used to model systems
that have large populations. But using differential equations, it is very difficult to capture the
dynamics and the characteristics of the system interactions in a smaller population of agents.
In the case of ODE, the spatial characteristics of the model are not taken into account. The
complexity and the stochasticity of the system are again very difficult to model using ODEs.
Partial Differential Equations (PDE) are used to build mathematical models of problems in threedimensional space, with varying behavior over time. Many of the phenomena that are shown by
the biological models can be represented by PDEs. But PDE systems are computationally
complex and may not be solvable in reasonable amounts of time, even for a small system [19].
Stochastic Differential Equations (SDEs) allow the stochastic behavior of the system to be
modeled. But SDEs are computationally very expensive.
In a nutshell, the main disadvantages of implementing a model using traditional methods can be
summarized as follows:
9
1. It is difficult to represent the complexity and stochasticity of the system.
2. Traditional methods may not take the spatial dynamics and the complexity of the
entities into account.
3. Almost all the methods use complex mathematical models which are difficult to
understand and computationally expensive.
4. With traditional approaches it is difficult to include both the discrete and the
continuous behavior into the same system.
2.2.3 Advantages of ABM
The advantages of Agent Based Modeling (ABM) over the traditional methods are as follows:
1. ABM captures emergent phenomena of global behavior from local interactions [14].
2. ABM provides a natural description of the system [14].
3. ABM is flexible.
4. ABM takes into account the spatial dynamics of the model.
5. The object geometries can be specified as needed.
6.
Higher orders of reactions including non-polynomial behaviors are possible.
7. Higher degree of reproducibility and reusability of code is possible because of OOP.
8. The control complexity is reduced due to decentralization of the objects.
9. ABM methods can capture the true granularity or stochasticity of complex systems.
10. ABM does not require as much mathematical knowledge as is required for traditional
methods [19].
10
2.3 Comparison of Various ABM Tools
ABM has become popular and as a result there are a variety of ABM tools that have been
developed. Here we compare some of the most popular ABM tools with respect to some of the
most important factors and then come to a decision about which tool we will use in the project.
The comparisons are summarized in Table 2.1.
ABM
Tool
Language
Availability
OS
Visualization
Parallel ism
User
Materials
Ascape
Java
JCChart
license; BSD
Open Source
license
Linux,
Windows,
Mac OS X
2D
NO
Good
documentation
Breve
A scripting
language;
steve
Free
Linux,
Windows,
Mac OS X
2D and 3D
(OpenGL)
NO
Pretty decent
documentation
Dex
Python
Free
Linux
2D and 3D
(OpenGL)
Yes
Very little
documentation
EINStein
Python
scripts
Free
Linux
2D
No
Good
documentation
ECJ
Java
Free for
academic
institutions
only
Linux
2D & 3D
No
Pretty decent
documentation
MAML
C,
Objective
C (unique
syntax)
Free
Linux
2D
Limited
Very little
documentation
MASON
Java
Free (open
source)
Linux,
Windows,
Mac OS X
2D and 3D
(OpenGL and
others)
Yes
(Very good)
Extensive
documentation
available
Repast
Java
Free (open
source)
Linux,
Windows,
Mac OS X
Extensive 2D,
limited 3D
Yes
Extensive
documentation
NetLogo
C, C++
Not free
Windows,
Linux
Very limited
No
Very good
documentation
Swarm
Objective
C
Free
Linux,
Windows,
Mac OS X
2D and 3D
Yes (very
difficult)
Extensive
documentation
Table 2.1: Comparison of Agent Based Modeling Tools
11
In the above table, various Agent Based Modeling tools have been compared with respect to
some of the most important and common characteristics. Information on most of these tools can
be found in [20]. Note that some ABM tools do not provide 3D visualization which is one of the
most important things that a biologist will need for looking at a system.
MASON provides a very good simulation tool kit and it is a good choice for experienced
programmers who are working on computationally intensive models [21]. MASON also has very
good 3D visualization ability and very good parallelization, which are the most important
features which we are looking at to model the system described below. NetLogo is easy to use
and it has got very good documentation, but the visualization abilities are not good when
compared to MASON. Repast is another well known Agent Based Modeling tool that has always
been in consideration, but again the visualization is excellent when it comes to 2D but not as
good when it comes to 3D. Swarm is stable, small and well organized and can support very
complex models, but it suffers from some of the faults of the Objective-C language, including
the very important garbage collection feature [20]. From the table, we have come to a conclusion
that we should use Repast, NetLogo or MASON as the tool of our choice. For those who will be
working on very simple models that do not have many agents, NetLogo will be the tool of
choice. We decided to go with MASON as the tool of choice because the system being modeled
has a lot of agents involved. However, MASON requires strong programming experience.
2.4 MASON: The ABM Tool of Choice
MASON stands for Multi-Agent Simulator Of Neighborhoods or Networks. MASON is a singleprocess discrete-event simulation core and visualization tool kit written in Java, designed to be
12
flexible enough to be used in a wide range of simulations. The system is open-source and free
and it is a joint effort of George Mason University’s Computer Science Department [22]. The
design principle of MASON was to build a fast, portable, orthogonal, minimal model library to
which an experienced Java programmer can add features. MASON is a tool kit wherein multiple
checkpoints can be added even during the simulation process. The model that is developed in
MASON can be attached to any GUI kit that is open-source or free and the visualization can be
added separately. So, in the process of development, MASON was considered to be a library that
is essential for supporting simple simulations and as a core for new simulation libraries.
Figure 2.2 explains one of the best features of the MASON model, the checkpoint and recovery
stage. At any point in the simulation, the model can be paused and then continued to run both in
the background as well in the front end. If one needs just the data, the visualization layer need
not be turned ON, which will make collecting the data easier.
Checkpointed
Recovered
Model running
in the
background
platform
Model
running in the
front end
platform Visualization
layer
DISK
(SimState)
Checkpointed
Recovered
Figure 2.2: MASON Model Checkpoint and Recovery Design [22]
13
2.4.1. Features of MASON
Some of the features of MASON are listed below.
1. MASON is 100% Java (excellent OOP concept with higher level of integrity, granularity)
along with garbage collection.
2. It is fast, portable and fairly small.
3. The Model layer is different from the Visualization layer. It can be removed or replaced
anytime.
4. Model can be check pointed and recovered and dynamically migrated across platforms.
5. MASON produces results that are identical across platforms.
6. MASON has excellent 2D and 3D visualization. Separate GUI interfaces can also be
added to the Visualization layer.
7. Excellent parallelization is possible in MASON, which is one of its most important
features.
8. MASON can generate PNG snapshots, QuickTime movies, charts and graphs and output
data streams.
2.4.2. MASON Architecture
MASON is written in Java in order to take advantage of its portability, strict math and type
definitions and serialization of the objects and agents in order to check point simulations. Check
pointing means the ability to stop, play or pause the simulation at any point of time. The tool is
written in a very modular manner and a layered architecture approach has been followed. As can
be seen from Figure 2.3, the model can be viewed as an entire GUIState which wraps the
Simulation Model (SimState) and separates it from the Visualization layer. The model can be
14
completely broken off and run on its own, and it can be serialized to/from disk. All these
modules inside these layers are considered to be self-contained and extra modules can be added
or replaced easily. The Model layer and the Visualization layer are explained in brief in the
following paragraphs. The different layers in MASON can be easily understood from Figure 2.3.
The Visualization Layer consists of the GUI interface, which portrays the 2D and 3D layers of
the underlying models in the SimState. It is the SimState model which can detach completely
from the model and serialize the SimState to/from the disk. The 2D and 3D Displays internally
inherit the Field Portrayals of 2D and 3D which will in turn inherit the simple/quad portrayals.
These portrayals are responsible for drawing or inspecting various kinds of objects stored in the
fields. The agents that are scheduled in the SimState can be controlled by the entire Console. The
Console is the place where a simulation can be started, stopped, paused or stepped. This is also
where we load or save serialized models, show or hide the visualization window and also load
other simulations.
15
GUIState
(API between SimState and the GUI (Console, Displays)
VISUALIZATION LAYER (GUI)
2D and 3D Displays
CONTROLLER
2D and 3D Field Portrayals
2D and 3D
Portrayals
SIMULATION MODEL (SimState)
Event Schedule
(Time)
Fields
Arbitrary
Objects
Agents
(Events)
Model can
be
serialized
to DISK
Mersenne TwisterFast Random Number Generator (RNG)
Figure 2.3: MASON Architecture [22]
The SimState or the Model layer consists of separate entities such as Fields, Schedule, and
Mersenne Random Number Generator(RNG) [23]. Each of these can establish its communication
thread within the model or even outside the model e.g., within the Visualization layer. MASON
describes each agent as a specific entity that can be scheduled to perform certain actions in the
environment. MASON does not schedule events on the schedule to send signals to the agents,
16
rather it schedules the agents themselves. If agents need to be grouped together to act in a certain
area, MASON allows this by using a wrapper class. The Field entity relates arbitrary values or
objects to locations.
Some of the important fields in MASON that were used to build the ABM model is shown in
Figure 2.4.
Figure 2.4: Important Fields in the Model in MASON
2.5 Case Study: The Cell Cycle
The cell cycle or the cell-division cycle is a series of events taking place in a biological cell that
gradually stage by stage leads to its replication. The cell cycle has been chosen as the system to
17
be modeled in our research. The reason is that the cell cycle process is very complicated and
requires a lot of wet lab experiments to observe its characteristics. As the goal of the thesis, a
simulation model of the cell cycle should be developed in order to assist biologists in
understanding this process. The model in this thesis is a simple one but it will form the basis for
more realistic models in the future.
There are various types of biological organisms and the cell cycles vary from one to another. For
example, in prokaryotes the cell cycle occurs through a process termed binary fission. The cell
cycle that is modeled in this thesis is the cycle that is exhibited in eukaryotes. Eukaryotes are
those organisms that have a nucleus and this differentiates them from prokaryotes. Animals,
plants and fungi are examples of eukaryotes. When we consider human cell types, there are over
200 cell types. Some of them are the cells that are present in the blood, in the endocrine, nervous
and respiratory systems, in skins and bones, and so on. For example, if we consider the blood
cells, the cells are formed by a process called erythropoiesis. Cells like keratinocytes are those
that can be found in epidermis, i.e., the skin. The cells in the eukaryotic category follow the cell
cycle process that is explained here and in more detail in chapter 3. Moreover, the cells that are
described in this model move on a substrate. Not all cells have a substrate, for example, the skin
cells or the epithelial cells have a substrate on top of which the cell moves. But in the case of
other cells like blood cells, the cells are produced in the bone marrow and they move around the
body [24].
The cell cycle has two main events taking place. One is cell growth and the copying of the
cellular components and the other is the cleavage of the cell. These two events, growth/copying
and cleavage, represent the two main phases of the cell cycle, Interphase and Mitosis. Briefly,
18
Interphase will be the state of replicating components and it will be the state where the cell will
get ready to enter the Mitosis phase. Since the cell cycle is a “cycle”, it has no beginning or end.
Cells are continually entering and exiting the various phases of the cycle. The various phases of
the cell cycle, its implementation and results have been discussed in detail in the following
chapter.
A basic model of the cell cycle has already been modeled by Walker et al. [25]. This paper
describes the cell cycle modeled as a two dimensional model. There are several ways in which
the model that is developed in this thesis improves on the model in [25].
1. The current model developed is a three dimensional (3D) model. This is one of the most
important features that are important from a biological perspective. A 3D model will have
more detail about the model when compared to that of the 2D model in [25]. For e.g., in
certain biological cases, like cancer progression [30], results in cells developing into a
tumor which can be better understood in a 3D model.
2. The system used to develop the 2D model was Matlab, while the system that is designed
in this thesis is modeled using Java in MASON, which allows for easy visualization,
modularity, and modification.
3. As already mentioned, MASON is a specialty tool for designing Agent Based Models and
Java is one of the most popular and efficient languages to design 3D models.
4. Java takes advantage of the OOP concept [12]. Agents can be modeled easily using these
concepts. Java has the feature of threads. It can be exploited to run different parts of the
code in parallel, in the process making the code efficient. Many GUI and IDE tools, e.g.,
19
Eclipse, are available for free for use with Java. This makes developing user interfaces
very easy.
2.6 Background of the Biological Aspects of the Model
This section explains the background that is involved in the biological side of the cell movement,
its formation and also the healing process in case of burns or wounds in collections of skin cells.
The following paragraph briefly describes cell movement.
In any biological system, the speed of cell movement is limited by the rate of cell-substratum
detachment at the cell rear [26]. Cell migration or movement on the substrate is a series of events
that includes lamellipodial extension, formation of the lamellipod-substratum attachments,
cytoskeletal contraction, and the release of the cell-substratum attachments at the rear [27]. The
factors that are responsible for cell migration are effectively lamellipod extension, cytoskeletal
force and the rear detachment. The speed of movement of the cell is regulated by the adhesive
interaction between the cell and its substrate. Cytoskeletal forces tend to break the cellsubstratum bonds at low adhesion but the cells are unable to generate sufficient traction to move.
In the case of high adhesions, the cytoskeletal forces cannot break the cell-substratum bonds
whereas when the adhesiveness is intermediate, the cytoskeletal forces will be such that they are
maintained in the front but they tend to get disrupted at the rear leading to cell locomotion [26].
The biological factors that are responsible for cell movement are shown in Table 2.2 [26].
20
Factor
Range
Total cell area
102-104 µm2
Cell rear area
101-103 µm2
Thermal energy
4.1 X 10-14 erg
Substrate adhesion constant (with
ligand and cytoskeleton)
10-8 – 10-6 M-1
Force at cell rear
10-1-101 nN/ µm2
Force to remove ligand from
substrate
0.1 – 100 µdyne
Cytoskeletal element density
109-1012 cm-2
Cell attachment time with substrate
or other cell
102-105 s
Table 2.2: Parameters Affecting Cell Movement [26]
Cells in extraordinary cases like wounds or burns get damaged or destroyed. Cells called
fibroblasts play an important role here in healing the wounded cells. Including the effect of
fibroblasts produces a complex biological model for computational modeling. A fibroblast is a
type of cell that synthesizes the extracellular matrix (ECM) and collagen. The ECM is the
extracellular part of the tissue that provides structural support to the cells in addition to
performing various other important functions [28]. Changes to the ECM environment may affect
the basic cell functions such as cell growth, apoptosis and proliferation [29]. These fibroblasts
involve a lot of study as their behavior is very complex and detailed analysis of them should be
done in future modeling of the system we are studying here.
21
Chapter 3
Implementation
Chapter 3 discusses the implementation of our model of cell growth. It describes how the model
initial conditions are made and the basic structure of the cell cycle. It also explains in detail about
the cell cycle process. Our assumptions about the biological process are taken from R. J.
Reynolds and J. A. Schecker [30]. Note that much of the complex cell behavior described in
Chapter 2 has not yet been added to this first iteration of the model. In particular, a simple model
of cell movement on a substrate has been implemented, since an eventual goal is modeling of
skin cells. But much more detail about cell bonding and movement, as described previously, will
need to be added eventually.
3.1 Initial Model Conditions and Basic Model Structure
Our model consists of a 3D environment which holds all the agents that will be interacting
among themselves, along with the agents themselves. The physical part of the environment is the
substrate of the cell, represented as a 3D rectangular region with user defined dimensions. Within
the substrate, the cells, represented as agents, interact to replicate the cell cycle. The model has
been designed in such a way that the number of cells and the type of the cells can be selected by
the user and they can also be placed in random locations in the 3D substrate as desired by the
user. Each type of cell modeled has a radius that can be varied to change the size of the cell. The
22
cells’ radii can also be selected by the user. The model has been designed in such a way that it is
very interactive with the user.
The model’s internal structure has been designed like an iterative process. It can be considered as
a clock, where each step in the process is described as a single tick. At the tick of the model
clock, each of the agents is checked for its status and, and depending upon the state of its internal
parameters and the environmental conditions such as the proximity of neighboring cells, each
agent will determine from its internal rules how it should react. MASON provides specific data
structures called bags to establish communications among themselves. So, in each tick, each
agent establishes communication with the bags data structure of other agents and information is
passed on to the agent. The bags are updated for all information that is changed within an agent
and for all information that is changed because of the agent. Hence they play a vital role in the
background process. They are more fully explained in the later sections of this chapter.
3.2 Rule-based Modeling
In the cell cycle, cells go through a series of steps which include growth, division, migration,
bonding and signaling [25]. In ABM, these steps are accomplished through the use of simple rule
sets assigned to each agent. This particular paradigm has been very successful in modeling other
interacting entities, for example, colonies of ants and bees [32] and even human systems [33],
which model how complex social systems have evolved. In these cases, there is no concept of
higher control, but each individual component of the system or agent executes a set of rules in
response to various environmental conditions [30].
23
3.3 Modeled Cell Types
There are four different cell types that have been modeled in MASON for implementing the cell
cycle regulation process. These cell types have been modeled as follows:
Cells
These types of cells are predicted to exist in many types of tissue. The fundamental property of
this type of cell is that they have the ability of self renewal and hence are very important in
maintaining a constant number. As explained in Chapter 2, the cells we are modeling can be in
two phases with respect to cell division, Interphase (growth/copying) and Mitosis (cleavage).
We are also modeling cells moving on a substrate. Thus the various behaviors these cells can
undergo are as follows:
Cell growth and division (Interphase and Mitosis)
Bonding (to a neighboring cell and also to its substrate)
Spreading
Migration
Apoptosis
Cells in Interphase
In this thesis the cells in the Interphase stage are further modeled as being in one of several
subphases:
G1 subphase (Cell growth)
G0 subphase (Checkpoint – Quiescent subphase)
24
S subphase (Synthesis subphase)
G2 subphase (preparing to enter M phase)
Mitotic Cells (M Phase)
The mitotic cells are said to be in the M phase of the cell cycle. Mitotic cells when formed break
up the intercellular bonds that are formed during the bonding of the cells. They usually do not
form any bonding until the mitosis stage is complete. These then automatically, after a certain
time, become cells in the G1 subphase.
Dead Cells
At the end of each full cycle, a check is made as to which cells are not bonded to the substrate.
Those cells that are not bonded to the substrate at this stage undergo apoptosis and they become
dead cells.
3.4 Cell Cycle Process
The model that is being developed is restricted to modeling only cellular based behaviors. The
subcellular mechanisms that are involved are essentially ignored in this model. The central hinge
of the model is the cell cycle and the whole model revolves around this mechanism. All the cells
that are capable of cycling through the model progress through every step provided that they are
not contact inhibited.
The cell cycle has three Interphase subphases, G1, S, and G2, and also M, the mitosis phase.
There also exists a checkpoint phase G0 that is between the G1 and the S subphase. The G1, S
25
and G2 subphases constitutes the Interphase. These phases and subphases are depicted in Figure
3.1.
G1
S
G2
INTERPHASE
M
G1
MITOSIS
S
INTERPHASE
G2
M
MITOSIS
Figure 3.1: Interphase and Mitosis Flow
The complete cell cycle process is shown in Figure 3.2.
G1
M
G0
G2
S
Figure 3.2: Cell Cycle Process
In Figure 3.2, the following phases and subphases are represented:
G0: check point that decides whether the cells go through the rest of the cycle.
S: DNA synthesis takes place within the cell. DNA synthesis is not modeled in the system.
G2: cells in this subphase have duplicated DNA and are ready to enter the Mitosis or M
phase.
M: phase where the cells undergo mitosis. The duplicated chromosomes are split and the cell
division occurs and two different cells are formed.
26
G1: indicates the completion of one cycle. It is also the subphase where the cells double in
volume.
Below we explain these in more detail. Remember the Interphase has three subphases, G1, S and
G2.
G1 Subphase
G1 is an intermediate subphase occupying the time between the end of the Mitosis (M) phase and
the beginning of the DNA replication during the S subphase. This subphase is the longest
subphase in the cell cycle process. So, in this G1 subphase the cell basically grows in size and it
gets ready for replication. Before the cell even actually goes into the replication stage, the cell
has to be checked as to whether it is fit to enter into the process. Those cells that do not satisfy
the requirements for the G1 subphase go through a checkpoint to enter a quiescent state. This
state is the G0 subphase. Figure 3.3 explains in brief what happens in this subphase.
DNA
Cell from M
(Mitosis) phase
(M)
Cell at the end of the
G1 subphase
Figure 3.3: Cell Activity in G1 Subphase
27
G0 Subphase
G0 is the subphase where the cell monitoring takes place. In this subphase, the cells in the G1
subphase are monitored and if they have not grown to the appropriate size for replication to take
place, these cells are sent to the G0 subphase. In this subphase, the cells can stay as long as they
meet the requirements to get into the replication stage. Depending upon the cells’ current state in
G0, it might take days or weeks for the cell to get itself back into the cycle. When the cell is in
the appropriate size, the cell will exit the G0 subphase and continue the cell cycle process.
S Subphase
In this subphase, the DNA in the chromosomes gets replicated. This is a process internal to the
cell. The agent based model doesn’t show this process as it is an intracellular process. Once the
DNA replication is complete, the number of the chromosomes in the cell should have been
doubled and from the S subphase the cell enters into the G2 subphase. This subphase is shown in
Figure 3.4.
DNA
Cell at the end of the
G1 subphase
Cell at the end of the
S subphase
Figure 3.4: Cell Activity in S Subphase
28
G2 Subphase
The G2 subphase is similar to that of the G1 subphase. This subphase can also be considered to
be similar to G1 subphase, where the cell after replicating its chromosomes in the S subphase,
will undergo a check before getting into the G2 subphase. In the G2 subphase, the cell will have
its final chance to grow. In other words, the cell gets itself prepared to get into mitosis phase
(M). As mentioned, since the model is intercellular, these changes will not be seen in the model.
M phase
When the cell enters the M phase, it has entered the final stage of the cell cycle process. This is
the place where cell gets divided into two. The main cell will divide into two daughter cells and
these cells get into the G1 subphase of the cell cycle process. From here, the cell cycle process
will be repeated. The process of the M phase can be understood from Figure 3.5.
DNA
Cell at the beginning of
M phase
Cell at the intermediate
stage of M phase
Figure 3.5: Cell Activity in M Phase
29
Cell at the end
of M phase
All the events and the subphases can be summarized so that the model can be understood clearly.
All this information is from the programming point of view and not from the biological point of
view. The summary is given in Table 3.1.
CURRENT STATE
ACTION
Cell is in G1
Cell size is increased and the indication of the new cycle
is noted by incrementing the program’s internal clock.
Cell is in G1/G0 checkpoint
If cell is bounded by 4 or more cells; ENTER G0
Cell is in G1/G0 checkpoint
If cell is not of the appropriate size; ENTER G0
Cell is in G0
If cell is bounded by less than 4 cells; ENTER G1
Cell is in G0
If cell is of appropriate size; ENTER G1
Cell is in S
The program’s internal counter is stepped up
Cell is in G2
Check for cell size again; Get ready to enter M phase
Cell is in M
Divide the cell into two identical cells.
Table 3.1: Tabulation of Rules Undertaken in Cell Cycle
We also need to explain the actions in which the cell is involved.
Bonding to the Substrate
Our eventual goal is to build a model of skin cells, which bond to a substrate. In our model and
in real life, the new cells that are formed due to mitosis are not bonded to the substrate. Every
iteration of the cycle will have a calculation based on a random number to determine whether the
cell should be bonded to the substrate. Once binding of the cell takes place it then goes through
the rest of the cell cycle.
30
Intercellular Bonding
The cell, as it migrates after bonding to the substrate, has the possibility to meet up with other
cells in the environment. Once it meets up with another cell, it bonds itself with the other cell and
then it undergoes mitosis and other processes from here on.
Spreading
In order to progress through the cell cycle, the cells spread by forming attachments to the
substrate. This process can be shown in the model by increasing the area of the cell so as to
immerse it in the substrate layer.
Migration
Those cells that are attached to the substrate and have no intercellular bonds (bonding between
cells) are free to migrate in the environment within a certain distance. The distance the cell can
move depends upon the internal factors of the cell. The migrating directions are assigned to these
cells randomly by using the random number generator. If its path is being blocked by a
neighboring cell or by the substrate edge, the cell will try to move towards another edge,
ensuring that it would not go out of the edge of the model. Such checks are repeatedly happening
in the background process.
Apoptosis
Cells that have failed to attach themselves to the substrate at the end of the G1 subphase become
dead.
31
3.5 Functioning of the Cell Cycle from a Programming Point of View
The environment is first loaded with an initial quantity of cells and then it is allowed to undergo
the changes depending on the environment. The user has the flexibility to decide which cell has
to be in the beginning stage of the simulation. A GUI will be presented in which the user can
enter the initial information and start the simulation. Since each cell is designed as an agent, it
uses its intelligence to learn the current conditions of the environment and then transforms its
state.
When the simulation is started, time progresses and the cells grow in size and they become
bigger. This is the G1 subphase of the cycle. After the cell has grown to its full size, it starts
migrating in the environment and in due course if this cell comes across any other cell in the
environment, intercellular bonding takes place. These cells stick to each other and they are still
in the cell cycle. The lifetime of each cell is noted down as the cell is born and after a certain
period of time, each cell would have undergone synthesis and the duplication of the DNA would
have also taken place. Now the cell would be ready to undergo mitosis and split into two
daughter cells. The splitting of the cell to give birth to two daughter cells is the M phase. Now
each daughter cell is in the G1 subphase and in this subphase, a checkpoint is introduced that
checks for contact inhibition and depending upon this condition, each cell will be able to go into
the quiescent subphase or continue the cell cycle. Contact Inhibition occurs when a cell has four
or more bonds with its neighboring cells. When almost all the cells in the environment have
bonded with four or more cells, the bonded cells go into the quiescent state, thus completing the
cell cycle.
32
3.6 Flowchart for the Agent Based Model
The simulation start up, the selection of the number of agents and the type of the agents and the
cell cycle process that is taking place in the model can be understood with the help of the
flowchart in Figure 3.6.
Initialize the number and the type of the cells
needed in the simulation
Synthesize the necessary agents in the substrate
Keep agents in random
motion
Check for cells
in beginning of
NO
G1 subphase
YES
Call cellgrowth() function
YES
Check whether
appropriate size
has been reached at
end of G1
NO
Check for
appropriate size
(or) contact
Enter
Quiescent
(G0
subphase)
inhibition
YES
NO
Enter S
Increment counter and Enter G2
Enter Mitosis (M Phase)
Divide cells into two identical daughter cells
Figure 3.6: Flowchart for the Agent Based Model
33
3.7 Composition of the Environments in the Model
MASON has many components with which the model can be built. As mentioned earlier,
MASON includes a Schedule, SimState, and MersenneTwisterFast random number generator,
plus various Fields containing the objects the agents are free to manipulate. The user can
manipulate the schedule through the Console, and view and manipulate the Fields and objects
through the Display 2D and Display 3D. The important thing is that we have to choose the right
Field in which we will implement our model. The Field in turn is classified into Grids and Sparse
Field. The Continuous3D Field is chosen for modeling the system. The environment in the
underlying model of the system, i.e., the SimState is modeled as Continuous3D. It is a storage
facility for the objects located in the Continuous3D Field. This facility relates objects with 3D
double tuples (in the form of Double3D). The facility extends SparseField, and like other objects
which extend SparseField (such as SparseGrid3D), the facility can only relate any given object
with a single location at a time, i.e., an object cannot hold two locations at once in the
Continuous3D field. The user interacting layer or the visualization layer has been modeled as
two
separate
portrayals.
One
is
the
ContinuousPortrayal3D
and
other
is
the
TransformedPortrayal3D. This will transform the objects with an underlying Transform3D,
meaning
that
you
can
rotate
them,
translate
them,
scale
them,
etc.
When
TransformedPortrayal3D is created, an underlying Portrayal3D represents the actual object and
from here TransformedPortrayal3D will then transform it as requested.
3.8 Agents Modeled in the System and Their Rules
The different agents in the system are the cell, the cell in its beginning state, the cell at the end of
the G1 subphase, the mitosis phase of the cell, the quiescent state (G0 subphase) and the
34
substrate. Each of these agents has their own set of variables and functions initialization. Each of
these functions are specified in the INIT() state in the program. All these agents are scheduled
using the Schedule event. Schedule defines a thread safe scheduling queue in which the events
can be scheduled to occur at a future time.
An event is defined by the Steppable object. One can schedule events to either occur a single
time or repeatedly at specific intervals. If the event occurs repeatedly, then the question of
stopping the event occurs. For this, the Schedule provides a Stoppable object which can be called
to stop the event.
The Schedule is initiated by calling its step() method. There is a particular time at which the
agents are scheduled depending upon the program’s internal calculations. This time is noted by
the Schedule and the Schedule moves ahead to that time and makes sure it updates all the agents
to be scheduled at that time.
The step() method keeps track of the number of steps each agent has gone through. A SimState
contains the random number generator and the simulator's schedule. One should not change the
schedule to another Schedule object. When a simulation is begun, SimState's start() method is
called. Then the schedule is stepped some N times. At last, the SimState's finish() method is
called, and the simulation is complete.
The rules that apply to the agents modeled in the cell cycle are as follows:
35
1. All the agents except for the substrate are spherical in shape. The substrate agent is made by
using the TransformedPortrayal3D and transforming the regular cuboid.
2. The CellBeg agent in the beginning of the G1 subphase is designed to have half the radius of
the CellEnd in the end of the subphase as the cell would have grown in size at the end of the
G1 subphase.
3. The time each agent is in a particular phase or subphase is recorded for future purposes.
4. All the agents in the model can be assigned velocities depending upon the study of the agent
in real time. The user interface allows one to do this.
5. At the beginning of each phase or subphase, the agent’s life time is checked and if any agent
is too old, it is killed.
6. At any point in the simulation, the agent is checked for contact inhibition, i.e., whether it has
been surrounded by 3 or more agents. If so, that particular agent goes into the Quiescent state
(G0 subphase) and it is represented as yellow in color.
7. The contact inhibition also accounts for the substrate, which is also an agent. The substrate is
defined as stationary.
8. All the agents that have exited the G2 subphase get ready to go into the M phase, where they
are represented as the CellBeg agents.
9. An agent in the G2 subphase is split into two cells, each with half of the original radius, in
order to represent itself in the M phase.
10. During this process, any collision between the agents results in the agents either undergoing
intercellular bonding or agents getting bounced off from each other.
11. At any time of the simulation, the agents should not cross the boundary of the substrate.
36
12. The substrate is modeled as a cuboid in the Continuous3D environment and all the other
agents are scheduled on top of it.
3.9 Unified Modeling Language Diagrams
Unified Modified Language (UML) is a standardized general purpose modeling language that
helps in representing OOP concepts. UML is like an extended version of a flowchart that
explains the entities in an OOP system in detail. In short, UML is a graphical language for
visualizing, specifying and constructing the artifacts of a software intensive system [34]. UML
combines the best concepts from data modeling such as Entity Relationship diagram, Class
Responsibility Collabarator (CRC) diagrams, and Class diagrams. It can also be extended to
include Agent UML (AUML) diagrams [35][36].
3.9.1 Entity Relationship Diagram
The Entity Relationship (ER) diagram is an abstract conceptual representation of structured data.
The entity can be identified as an object that can be recognized as being capable of existing
independently or that can be uniquely identified. A relationship has two or more entities that are
related to one another. Both the entities and their relationships can have their attributes. There
are a number of conventions with which the ER diagram can be represented. This model has
been represented with one of the most commonly used conventions.
Figure 3.8 shows the ER diagram for the agent based model. The agent based model is modeled
in an environment. The system is the overall entity. The system has the environment and the
37
CELL. The environment which is inside the system also holds the CELL. Likewise, the different
classes are held by some other classes in the model.
Environment
System
CELL
Stationary
Mobile
Substrate
Monomer
Mitosis
Monomer
Dimer
CELL
Monomer
CELL
Dimer
Quiescent
Class
Is a relationship
Has a relationship
Figure 3.7: Entity Relationship Diagram of the Model
3.9.2 Class-Responsibility-Collaboration Cards and Class Diagrams
Class-Responsibility-Collaboration (CRC) cards are basically index cards that are used to
represent the responsibilities of the classes and the interactions that take place between them.
38
CRC cards are an informal approach to OOP. A class represents a collection of similar objects, a
responsibility is something that a class knows or does, and a collaborator is another class that a
class interacts with to fulfill its responsibilities. These cards are modeled based on the system
requirements that model the system [35].
The CRC cards for the agent based model are given in Figure 3.9(a), Figure 3.9(b) and Figure
3.9(c):
CELL
Responsibility
Collaborator
Check lifetime
CELL
Check collision within
CELL
Check collision with quiescent
CELL, Quiescent
Calling quiescent
Quiescent
Delete standalone
CELL
STATIONARY
Responsibility
MOBILE
Collaborator
Responsibility
Set the size of the object
Collaborator
Set the velocity, size and
direction of the object
Get the size of the object
Get vel., size & direction
Figure 3.8(a): CRC Card for the CELL, STATIONARY and MOBILE classes
Figure 3.8(a): CRC Card for the CELL, STATIONARY and MOBILE Classes
39
SUBSTRATE
Responsibility
Collaborator
Set the location of
the substrate
Get the location of
the substrate
Check distance
between all agents
CELL, Cell Monomer, Cell Dimer,
Mitosis Monomer, Quiescent
MONOMER
Responsibility
DIMER
Collaborator
Responsibility
Set and get the shape of the
Monomer.
Set and get the shape of the
Dimer.
Set and get the size of the
Monomer.
Set and get the size of the
Dimer.
Move the Monomer to a
different location
depending on the velocity.
Move the Dimer to a
different location depending
on the velocity.
Collaborator
CELL Monomer
Responsibility
Collaborator
Check collision within
Cell Monomer
Check collision with others
CELL, Cell Dimer,
Mitosis Monomer,
Quiescent
Check for randomness
Cell Monomer
Check for lifetime
Cell Monomer
Removal of cells
Cell Monomer
Figure 3.8(b): CRC Cards for Substrate, Cell Monomer, Monomer and Dimer Classes
40
CELL Dimer
Responsibility
Collaborator
Check collision within
Cell Dimer
Check collision with others
CELL, Cell Monomer, Mitosis
Monomer, Quiescent
Check for randomness
Cell Dimer
Check for lifetime
Cell Dimer
Removal of cells
Cell Dimer
Mitosis Monomer
Responsibility
Collaborator
Check collision within
Mitosis Monomer
Check collision with other
agents
CELL, Cell Monomer, Cell Dimer, Quiescent
Check for distance
CELL, Cell Monomer, Cell Dimer, Quiescent,
Mitosis Monomer
Check for lifetime
Mitosis Monomer
Movement
Mitosis Monomer
Removal of cells
Mitosis Monomer
Quiescent
Responsibility
Collaborator
Check for Movement
Quiescent
Check for collision between
Quiescent and CELL agents
CELL, Quiescent
Check for collision within
Quiescent
Quiescent
Delete
Quiescent
Result
Quiescent
Figure 3.8(c): CRC Cards for Cell Dimer, Mitosis Monomer and Quiescent Classes
41
Class diagrams for the agent based model are given below, in Figure 3.9(a). The class diagrams
have three sections. The first section specifies the name of the class. The second section specifies
the attributes of the class. The third section specifies those operations that are performed by the
class.
CELL
- size
- shape
- velocity
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ getCollisiondistance()
+ delete()
MONOMER
- size
- shape
- move
+ setsize()
+ getsize()
+ setshape()
+ move()
DIMER
- size
- shape
- move
+ setsize()
+ getsize()
+ setshape()
+ move()
STATIONARY
- size
- shape
+ setsize()
+ getsize()
+ setshape()
SUBSTRATE
MOBILE
- location
- distance
- collision
- size
- shape
- velocity
+ setsize()
+ getsize()
+ setshape()
+ setvelocity()
+ chkdistance()
+ chkcollision()
+ setsize()
+ getsize()
+ setshape()
+ setvelocity()
CELL MONOMER
CELL DIMER
- birthtime
- lifetime
- collision distance
- delete
- birthtime
- lifetime
- collision distance
- delete
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ chklifetime()
+ chkcollisionwithin()
+ chkcollisionother()
+ delete()
+ setStopper(Stoppable)
+ step(SimState)
+ stop()
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ chklifetime()
+ chkcollisionwithin()
+ chkcollisionother()
+ delete()
+ setStopper(Stoppable)
+ step(SimState)
+ stop()
Figure 3.9(a): Class Diagrams
42
MITOSIS MONOMER
QUIESCENT
- birthtime
- lifetime
- collision distance
- delete
- birthtime
- lifetime
- collision distance
- delete
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ chklifetime()
+ chkcollisionwithin()
+ chkcollisionother()
+ delete()
+ setStopper(Stoppable)
+ step(SimState)
+ stop()
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ chklifetime()
+ chkcollisionwithin()
+ chkcollisionother()
+ delete()
+ setStopper(Stoppable)
+ step(SimState)
+ stop()
Figure 3.9(b): Class Diagrams for Mitosis Monomer and Quiescent Subphases
3.9.3 Agent UML
“Agent UML is a formalism for specifying multi-agent interaction” [36]. Agent UML (AUML)
synthesizes a growing concern for agent-based methodologies with the increasing acceptance for
UML for object-oriented software development [36]. The main reason for explaining the concept
using AUML is that UML can explain in detail the functioning of an object but not an agent. The
agent interactions can be best explained with AUML. The main actions for an agent are
communicating with other agents and taking necessary actions that can change its state in the
environment. In this section, we can see how UML diagrams can be used to extend the
framework of object oriented programming development. Communicative Act (CA) is used to
represent the sent or the received class from another agent’s class or any of its instances [37].
The AUML consists of two main parts, the first one being the class diagram and the second one
43
being the agents interactions represented as CA’s. The CA’s to the left of the class diagram are
referred to as protocols that are incoming, i.e., the information that is obtained by the agent from
the environment. The CA’s to the right of the class diagram are referred to as protocols that are
outgoing, i.e., the effect that this particular agent has on the environment. Figure 3.11 shows the
AUML for the Substrate class.
SUBSTRATE
- location
- distance
- collision
+ setsize()
+ getsize()
+ setshape()
+ setvelocity()
+ chkdistance()
+ chkcollision()
All agents /
collision distance()
All agents /
chkcollisiondistance()
All agents / get
Objectlocation()
All agents / return
Objectlocation()
All agents /
chkcollision()
All agents / return
Boolean value()
Figure 3.10: Class Diagrams for Substrate Class Using AUML
From Figure 3.10, the substrate agent’s behavior can be better understood as its interactions to
and from the environment are clearly seen. The other classes have almost the same behavior and
hence they are explained by similar AUML diagrams, as seen in Figure 3.11.
44
CELL MONOMER, CELL DIMER,
MITOSIS MONOMER, QUIESCENT
- birthtime
- lifetime
- collision distance
- delete
+ getbirthtime()
+ setbirthtime()
+ getlifetime()
+ setlifetime()
+ chklifetime()
+ chkcollisionwithin()
+ chkcollisionother()
+ delete()
+ setStopper(Stoppable)
+ step(SimState)
Mobile /
get birthtime()
Mobile / return
birthtime()
Mobile /
get lifetime()
Mobile / return
lifetime()
Mobile /
chkcollisiondistance()
Mobile / return
distance() and agent
Stationary /
chkcollisiondistance()
Stationary /
return distance()
Mobile /
getobjectswithindistance()
Mobile / return objects
in a bag (structure)
Mobile /
stop()
Mobile / returns
the stoppable
object
CELL /
delete()
CELL / returns all
objects except deleted
Figure 3.11: Class Diagrams for Other Classes Using AUML
45
3.10 Data Structures in the Code
In our model, we are modeling the entire system in Java 3D and Java is known for its efficient
OOP concept. The entire model is available in a package inside MASON at sim.app.Skin. The
Skin will in turn package all the classes i.e., the Skin, SkinWithUI, CELL and others. The Skin
class is the main class in the model as it extends (inherits) the SimState. The SimState is the top
level object in MASON and at least one of the classes from the package should extend this
particular class.
SKIN Class
All the objects or the agents in the model should be present in an environment. MASON
provides several environments like the Continuous or the Grid fields. The Continuous field in
turn has Continuous2D and Continuous3D fields. The Grid field has a lot of fields. The
appropriate choice for the field for the environment is either the Continuous3D or the
SparseGrid3D field. We are looking for an efficient way to store the objects and then at a later
stage an efficient way to retrieve the objects. Continuous3D has a certain special kind of data
structure which it uses to look up the objects that are stored in it. It has been arranged to make
the neighborhood information lookup efficient. It discretizes the entire space into grid buckets.
This discretization bucket size is specified by the programmer and is not left to the user. The
main issue in using the Continuous3D is that the bucket size has to be appropriate. If the bucket
size is too big, one will be searching through too many objects and wasting time. In contrast,
SparseField3D uses a lookup methodology that returns all the objects at the defined location.
This particular approach will be very expensive in terms of execution time.
46
SkinWithUI Class
The SkinWithUI class extends (or inherits) the GUI class that is responsible for any graphical
interface. The GUI class has the same start() and finish() methods as the SimState and
additionally the GUI has the init(Controller) and the quit() methods. The init() as the name
indicates is the one that is responsible for setting up the environment and hence all the code
responsible to set up the environment goes into this section. At the end of the simulation, if it
needs to be terminated the quit() method is called to take care of disconnecting the threads and
other communications between the controllers and the displays.
Other Classes
Apart from these two classes, the other classes represent the agents involved in the system. These
agents will have their own collision detection, movement and other functions that are responsible
for their functioning in the environment.
Interface Class
The Interface class is the one that is responsible for the applet that comes up before the
simulation starts. The applet window has the fields requesting the user’s information and the
information is connected to the SimState which then tells the GUIState what the display and the
controller should do.
47
Chapter 4
Results
Chapter 4 shows the results that are obtained from various simulations that are performed with
the model.
4.1 Simulation Arrangement
This simulation is run in an Integrated Development Environment or Integrated Debugging
Environment (IDE) which is an application containing various tools that help in software
development. There are various IDE’s in the market that can be used to run Java. Some of them
which were considered for this thesis were JCreator, NetBeans and Eclipse. For this thesis, the
environment chosen was Eclipse.
The MASON library is downloaded from the homepage of MASON and it is imported into the
Eclipse IDE. Now, MASON can be accessed easily through this GUI instead of going through
the more lengthy process of accessing MASON through the terminal (DOS) window. Using
Eclipse also saves a lot of time because debugging is easier.
The Eclipse IDE is available for Windows, Linux and MacOSx. The current version of Eclipse
can be downloaded from its website.
48
The simulation is run on an Intel Centrino Duo processor running at 1.6GHz. The system has
2GB RAM running Windows Vista Home Premium Edition.
4.2 Parameters Involved in the Simulation
Figure 4.1 shows all the initial parameters involved in this simulation. These values are
explained below.
Figure 4.1: Parameters Involved in the Simulation
Different values can be entered in the fields and when the SUBMIT button is clicked, the values
are passed on to the SimState layer. But, if one needs to simulate the program using default
values, that button is hit. This window appears when the GUI class file (SkinWithUI.java) is run
49
in the IDE. This model is a generic model and if the parameters are mentioned for a specific
biological case, those values can be entered and observed. The parameters window opens up and
the simulation and console windows also open up. The console window is shown in Figure 4.2.
Figure 4.2: Snapshot of the Console Window
The console window is the one that is used to play, pause and stop the simulation at any time. It
has several different tabs, each of which has some information about the simulation. The second
tab is can be used to control the simulation speed.
The base parameters that are considered in the simulation are shown in Table 4.1.
50
Type of Cell
Time
No of cells in the beginning of G1 subphase
5
Lifetime for the cells in the beginning of G1 subphase
50
No of cells in the intermediate stage of G1 subphase
2
Lifetime for the cells in the intermediate G1 subphase
50
No of cells in the end of G1 subphase
10
Lifetime for cells in the end of G1 subphase
150
No of cells in the Quiescent(G0) subphase
0
No of cells in the Mitosis(M) phase
0
Lifetime for the cells in M phase
50
Table 4.1: Base Parameter Values Considered for the Simulation
The lifetime of the cells in the cell cycle has also been modeled in a relative fashion. In the case
of mammals, the average cell cycle duration is on the average 24 hours [31]. G1 is typically the
longest subphase which lasts for about 10 hours, followed by S subphase which lasts for around
5-6 hours and then followed by G2 subphase which lasts for a maximum of 4 hours. The
Interphase as a whole lasts for 20 hours. The M phase which is the cell division phase lasts for 2
hours. So from the times described, the cell cycle follows the ratio 1:0.5:0.5:0.2 (G1:S:G2:M).
The values for G2 subphase and S subphase has been modeled in this ratio, but MASON has the
capability to tweak these values and change them if needed.
51
The different types of cells have been modeled in different sizes. The cells in this thesis have
been modeled in a relative fashion. The sizes of the different types of cells involved in the cell
cycle are taken from Goodsell [32]. The average size of the cells is in the range of micrometers
and it varies from 30µm in the case of skin cells to 8µm in the case of blood cells [32]. The ratio
that is used for modeling the cells is shown in Table 4.2.
Type of the Agent Modeled
Size
Cells in beginning of G1 subphase
X
Cells in the end of G1 subphase
2X
Cells in the S subphase and G2 subphase
2X
Cells in the beginning of M phase
2X
Cells at the end of M phase
X
Substrate’s length
100X
Substrate’s width
100X
Substrate’s height
2X
Table 4.2: Size of the Agents Modeled in the System
4.3 Simulation Results
Figure 4.3 below shows the substrate of the model which is dark grey in color. It also shows
some agents. This is the initial stage of the simulation process which is the initial stage of the cell
cycle process. From here, the cells are scheduled by the back end of the program. The initial
placements of the agents are random on the substrate. These random locations are generated by
the MersenneTwisterFast RNG as discussed in previous sections.
52
The simulation has been done with the base parameter values and the snapshots of the simulation
are explained in this chapter.
The following figures will give a detailed description of each and every step in the model. As
already discussed in Chapter 3, the simulation will follow the cell cycle behavior.
Figure 4.3: Snapshot of the Initial Condition of the Simulation
Figure 4.3 shows the initial starting point of the simulation. The agents or the cells that are seen
in this figure come from the values that are entered in the parameter window that is shown in the
beginning of the simulation in Figure 4.1.
53
The cells or the agents in the above figure during the simulation act according to the situations in
the environment. The red cells that are bigger in size are the cells at the end of the G1 subphase
and the rest of the cells are those that are at the beginning of the G1 subphase.
These cells progress through the cell cycle and each stage is shown clearly in the figures that
follow. Figure 4.4 is the snapshot from the simulation when some cells have passed the S and the
G2 subphase and are now in the Mitosis (M) phase. The cells in the M phase are green in color.
Figure 4.4: Snapshot of Agents in M phase
Now that some agents are in the M phase and some agents are in G1 subphase, either at the end
or the beginning, the agents are simulated in parallel just like in real time. The action of one of
the agents will not hinder the actions that the other agents are performing. Therefore, each agent
will behave according to the environmental conditions. The agents in the M phase now go into
54
the G1 subphase and simultaneously those agents that are in the end of the G1 subphase go
through the S subphase and the G2 subphase and enter the M phase. Figure 4.5 shows this.
In Figure 4.5, the agents that are green in color are the agents that were at the end of the G1
subphase in Figure 4.4. Similarly, the agents that are red in color are those agents that were in the
M phase in Figure 4.4. These two figures give a clear picture of how the agents are behaving in
the model.
Figure 4.5: Snapshot of Agents in G1-S-G2-M Phase and M Phase-G1 Subphase
As the simulation progresses, some of the agents go into the G0 state, i.e., the quiescent state
because of the Contact Inhibition phenomenon. This phenomenon was explained in Chapter 3 in
Section 3.5. An agent that has entered into the quiescent state is shown in Figure 4.6.
55
In Figure 4.6 there is an agent that is yellow in color. It is this agent that is in the quiescent stage.
The agent will exit from the quiescent stage when the contact inhibition condition fails. From
here on, the simulation will progress continuously until the entire substrate is occupied with
agents.
Figure 4.6: Snapshot of Agent in G0 Subphase
Figure 4.7 and 4.8 show simulation snapshots at an intermediate stage of the simulation and at
the end respectively.
56
Figure 4.7: Snapshot of the Model at an Intermediate Level
Figure 4.8: Snapshot of the Model Towards the End
Figure 4.8 contains nearly ten thousand agents and they were all active during the simulation.
The number of agents increases over the simulation as can be seen from the data in Table 4.3.
57
Time Step
Iteration
Number
No. of Quiescent
Agents
Total No. of
Agents
0
0
0
0
500
1
0
2
1000
2
0
5
1500
3
2
8
2000
4
13
20
2500
5
37
65
3000
6
49
103
3500
7
82
149
4000
8
177
213
4500
9
233
528
......
.....
10500
21
3004
3518
11000
22
3170
3545
11500
23
3473
3690
12000
24
3662
3876
Table 4.3: Number of Agents During the Simulation
The simulation is run until the entire substrate is occupied with agents. This will happen
gradually as the cells grow in size, get synthesized and divided and then go back into the G1
subphase. Each cell also undergoes a regular check when it is passing through the checkpoint
G0.
58
It can be seen from the time step values that for the first few intervals no quiescent cells are
observed. After around 2500 steps, a significant number of agents are present in the quiescent
state. From then on, the number of quiescent agents starts to increase significantly because the
phenomenon of contact inhibition becomes more prominent as the number of cells increases.
From the results above, a graph shown in Figure 4.9 is plotted for the number of agents in the
quiescent subphase against the time steps. Each cycle in the simulation is around 500 time steps,
i.e., 500 steps in the base simulation of the model is considered to be a single cell cycle. In this
single cycle of 500 steps, a particular agent will cycle through all the stages of the cell cycle. The
delay of these steps can also be adjusted with the console window as mentioned in Section 4.2.
Figure 4.9: Cell Growth Characteristics with Base Parameters
59
The entire simulation model is an iterative process that goes in a loop, one cycle after another.
Each cycle in the simulation model can be either sped up or slowed down using the delay option
in the console window as mentioned earlier. Each of these cycles in the simulation represents
around 24 hours in real time [25] [31] [39]. These values will obviously vary as a result of
changes in the physical conditions of the cell cycle.
4.4 Simulation of Wound Condition
An extension to the existing preliminary model is given in this section. In certain cases, for
example, in the case of skin cells, there is a possibility that an external stimulus or activity can
get rid of certain portions of the cells during the cell cycle process. So, the simulation model has
been used for such an external condition. The snapshot of the cell substrate after cells have
occupied most of the substrate is shown in Figure 4.8. At this point of time, certain portions of
the cells in the substrate are deleted and a snapshot of the result is shown in Figure 4.10.
Figure 4.10: Snapshot When Cells Are Deleted
60
This simulation is once again run. Note that any damage that has occurred to a particular cell
cannot be simulated in this model, as simulating the recovery of a single cell from a damaged
condition itself involves lots of conditions and analysis. Figures 4.11(a)-4.11(g) are snapshots
from the simulation of the wound condition case.
Figure 4.11(a): Snapshot Taken at 29th Iteration
Figure 4.11(b): Snapshot Taken at 30th Iteration
61
It can be seen from the above figures that as the simulation progresses, the cells start to occupy
the deleted area.
Figure 4.11(c): Snapshot Taken at 32nd Iteration
Figure 4.11(d): Snapshot Taken at 37th Iteration
Figure 4.11(e): Snapshot Taken at 42nd Iteration
Figure 4.11(f): Snapshot Taken at 47th Iteration
62
As can be seen from the series of figures above, the cells grow in size and multiply and they try
to reach the state they were in just before deletion took place. A few more iterations will make
the substrate look as follows:
Figure 4.11(g): Snapshot Taken at 51st Iteration
From all the figures, a general understanding of the cell cycle simulation process can be
understood. The more area that is deleted from the substrate, the more time it is going to take for
the simulation to make the substrate fill up with cells just like it was before deletion.
Figures 4.12 and 4.13 show the cell count for the above example over time.
This case can be made much more accurate in future versions of the model by including more
detailed biological information about how cells move on the substrate, as explained above.
63
Cell Growth Characteristics under Wound Condition
4500
Number of Cells / Agents
4000
3500
3000
2500
2000
1500
1000
500
0
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30
Iteration Number
Number of Cells / Agents at end of an iteration
Figure 4.12: Cell Growth Characteristics When Wound Occurred
Cell Growth Characteristics under Wound Condition
4500
Number of Cells / Agents
4000
3500
3000
2500
2000
1500
1000
500
0
1 3 5 7 9 11 13 15 17 19 21 23 25 27 29 31 33 35 37 39 41 43 45 47 49 51
Iteration Number
Number of Cells / Agents at end of an iteration
Figure 4.13: Cell Growth Characteristics After Stabilization
64
4.5 Variation of Simulation Parameters
The simulation parameters in Figure 4.1 can be varied at the beginning of the simulation. These
parameters control the entire simulation of the model. The entire cell cycle duration on the
whole can be changed by changing the lifetime values of the different cells or the agents that are
involved in the simulation. For example with the base parameter values considered, single cell
cycle duration was 500 time steps which is equivalent to a single iteration. If the length of the G1
subphase is set to a different value, the entire cell cycle will finish in fewer of cycles even though
it takes the same number of iterations. This is how the entire cell cycle process can be changed.
Some other variations that can be done are as follows:
1. In the background, the substrate agent size can be varied depending on the needs again.
2. The size of the various agents involved in the simulation can be changed. For example,
the size of the cells in mitosis can be changed which will eventually vary the behavior in
occupying the substrate area.
3. Even the shape of the agents can be changed. When simulating certain specific cases, a
cell might be ellipsoidal and not spherical.
4. Detailed interaction between the agents can be developed at the background level.
4.6 Improvements Suggested by Biologists
The model after completion was shown to biologists to get their viewpoint. I would like to
personally thank my colleagues Swathi Balaji and Varun Krishnamoorthy again for their time
and suggestions about the model.
65
The main improvements suggested were as follows:
1. The cell movement in real time occurs as a repeated cycle of membrane protrusion and
attachment, cytoskeletal contraction and rear detachment [40]. These are intracellular
components that should be analyzed and then can be incorporated in the model. The
model so far has the ability to change the velocity at which each and every cell moves.
Hence, for a certain cell model when the cell movement values are known, they can be
used to replace the values of the velocities of each and every cell in the source code.
2. Another suggestion is that the cells move around the substrate as a matrix. This
suggestion was made when the wound condition was simulated. The cells at the edge of
the substrate as observed in Figure 4.11(c) start moving along with the cells near the
deleted area. This kind of behavior will not happen in real cases because of the matrix
behavior existing between the cells. This is a good future work that can be implemented
to make the model better.
4.7 Performance Graph
Figure 4.14 shows the percentage of the processor used over the time the simulation started. It
can be seen that over 80% of the processor has been in use most of the time and hence we need
to move towards parallelization. The graph shown below is for the normal cell growth case.
66
Figure 4.14: Performance Graph of the System
67
Chapter 5
Conclusions and Future Work
5.1 Conclusions
In this research, an agent based model of cell cycle regulation has been developed. The ABM
gives a detailed approach to the modeling of this biological system. This is because the ABM
takes into account the spatial aspects. This is one of the important factors in the analysis of ABM
that other mathematical models do not easily take into account. As discussed in Chapter 2, a
detailed analysis has been made of which ABM tool can best be used to model the system. There
were requirements that an ABM tool should meet in order for it to be considered to model the
system. Some of these requirements are that an ABM tool should be robust and efficient and
should have very good 3D visualization capability and parallelization features. Of all the various
tools studied, MASON was the best choice for this project.
The system we chose to model is the cell cycle regulation. To start with, a basic model of the
cell cycle regulation has been designed. The entire model has been written in Java and the
visualization is in 3D. Chapter 3 has a separate section on UML that explains about the code
used in modeling the system. Special UML diagrams such as the Agent UML (AUML) are also
presented to give a detailed explanation about each agent’s behavior in the code.
68
The simulations have been performed for a set of base parameters. The figures or the graphs that
have been obtained from the simulation explain the behavior of the cell cycle. The base
parameters that are presented in Chapter 4 can be changed during the initiation of the simulation
to march those in experiments undertaken by biologists.
This agent based model is very useful to study cell cycle regulation at the intercellular level. This
model has been developed with techniques employed in previous work on ABM models [25].
The current model developed is more robust and efficient as it can simulate large numbers of
agents. The current biological system that is being modeled is much more complex when
compared to the previous model.
5.2 Future Work
The current simulation simulates a system that has around ten thousand agents. This simulation
can perhaps handle twenty to thirty thousand agents effectively. When the agent count increases
to around fifty thousand or one hundred thousand, the time that the system takes to simulate will
be very high. Time is a very important factor because when the time taken to simulate a system
is measured in days, in vitro instead of in silico simulation may make more sense. To make sure
that the simulation time is appropriate, the model can be parallelized. Parallelization is a concept
wherein different agents will be assigned to different processers that can simulate them
separately, thereby increasing the efficiency and decreasing the simulation time. MASON is
capable of supporting parallelization and that is one of the main reasons for selecting MASON as
the ABM tool of choice.
69
The entire model can be improved by improving the small parts of the model. For example, all
the cells in this model have been considered as spherical, but there might be conditions where
during collision a cell might change its shape. This is where the agent geometry, physics and
physical models of motion come into effect. Focusing on all of these factors will result in a better
model.
The current model is at an intercellular level. The model can be improved if an interaction
between any two agents can be modeled in more detail or if the model also functions at an
intracellular level. Intracellular level can be seen in cases when the cell in G1 phase goes into M
phase. During this process, there are several reactions taking place at an internal level that can be
modeled in MASON. Including these would make the model more precise. This model has been
designed such that it can qualitatively represent the system. Kinetic behavior of the system is
also an important factor for making the model more precise. Including this behavior will result in
a model that can quantitatively and accurately represent the biological system’s behavior.
We can summarize the future work as follows:
1. Parallelize the system to increase computational power.
2. Focus on the agent geometry, physics and physical models of motion for making the
model more precise.
3. Model the system at the intracellular level and then deploy it in the intercellular ABM,
making the overall model even more precise.
4. Include more physical information to make the model more quantitative.
70
5.3 Presentation Based on this Work
This thesis work has been presented at the Ohio Collaborative Conference on Bioinformatics
held at Toledo, Ohio in June 2008 [41].
71
Bibliography
1. H. Kitano, “Systems Biology: a brief overview”, Science, vol. 295. March 2002, pp.16621664.
2. E. Bonabeau, “Agent-based modeling: Methods and techniques for simulating human
systems”, Proceedings of the National Academy of Sciences, vol. 99, May 2002, pp. 72807287.
3. D. Ross, “Game Theory”, The Stanford Encyclopedia of Philosophy, Edward N. Zalta ed.,
August 2008.
4. P. Cilliers, Complexity and Postmodernism: Understanding Complex Systems, Routledge,
London, February 1998.
5. A. Aderem, “Systems biology: Its practice and challenges”, Cell (Cambridge), vol. 121, issue
4, May 2005, pp. 511-513.
6. N. Gilbert and K. G. Troitzsch, Simulation for Social Scientists, 2nd ed. Open University
Press, New York, 2005, pp. 115.
7. M. Wooldridge, An Introduction to MultiAgent Systems, John Wiley & Sons Ltd, New York,
2002.
8. A. E. Eiben and J. E. Smith, Introduction to Evolutionary Computing, Springer, New York,
October 2008.
72
9. J. M. Epstein and R. L. Axtell, Growing Artificial Societies: Social Science from the Bottom
Up, The MIT Press, Cambridge, November 1996.
10. R. Axelrod, The Complexity of Cooperation: Agent-Based Models of Competition and
Collaboration, Princeton University Press, Princeton, August 1997.
11. C. Reynolds, “Computer animation with scripts and actors,” Proceedings of the 9th Annual
Conference on Computer Graphics and Interactive Techniques, 1982, pp. 289 -296.
12. B. Stroustrup, The C++ Programming Language, 3rd ed. Addison-Wesley Professional,
Boston, February 2000, pp. 158-160.
13. C. M. Macal and M. J. North, “Tutorial on agent-based modeling and simulation,”
Proceedings of the 2005 Winter Simulation Conference, 2005, pp. 2-15.
14. E. Bonabeau, “Agent-based modeling: Methods and techniques for simulating human
systems,” Proceedings of the National Academy of Sciences, vol. 99, May 2002, pp. 72807287.
15. J. L. Casti, Would-Be Worlds: How Simulation is Changing the Frontiers of Science, John
Wiley & Sons Ltd, New York, February 1998.
16. J. Desel and G. Juhás, What Is a Petri Net? Informal Answers for the Informed Reader, vol.
2128, Springer, Berlin, 2001, pp. 1-25.
17. A. Regev, W. Silverman, and E. Shapiro, “Representation and simulation of biochemical
processes using the pi-calculus process algebra”, Pacific Symposium on Biocomputing, vol.
6, 2001, pp. 459-470.
18. H. V. Dyke, R. Savit, and R. L. Riolo, “Agent-based modeling vs. equation-based modeling:
A case study and users’ guide”, Proceedings of Workshop on Modeling Agent Based Systems
(MABS98), 1998, pp. 10-25.
73
19. D. S. Wishart, R. Yang, D. Arndt, P. Tang, and J. Cruz, “Dynamic cellular automata: An
alternative approach to cellular simulation,” Silico Biology, no. 4, 2004, pp. 1-3.
20. M. Berryman, Review of Software Platforms for Agent Based Models, Defense Science and
technology operation, Land Operations Division, Edinburgh, Australia, 2008, pp. 9-15.
21. S. F. Railsback, S. L. Lytinen, and S. K. Jackson, “Agent-based simulation platforms:
Review and development recommendations,” Simulation, vol. 82, 2004, pp. 609-623.
22. S. Luke, C. Cioffi-Revilla, L. Panait, and K. Sullivan, “MASON: A new multi-agent
simulation toolkit,” Proceedings of the 2004 SwarmFest Workshop, 2004, pp.1-7.
23. M. Matsumoto and T. Nishimura, “Mersenne twister: a 623-dimensionally equidistributed
uniform pseudorandom number generator,” ACM Trans. Model. Comput. Simul., vol. 8, no.
1, January 1998, pp. 3-30.
24. C. Vera, R. Skelton, F. Bossens and L. A. Sung, “3-D Nano-mechanics of an Erythrocyte
junctional complex in equibiaxial and anisotropic deformations,” Annals of Biomedical
Engineering, vol. 33, no.10, 2005, pp.1387–1404.
25. D. C. Walker, J. Southgate, G. Hill, M. Holocombe, D. R. Hose, S. M. Wood, S. Mac Neil,
and R. H. Smallwood, “The Epitheliome: agent-based modeling of the social behavior of the
cells,” Biosystems, vol. 76, no. 1-3, 2004, pp. 89-100.
26. S. P. Palecek, A. F. Horwitz, D. A. Lauffenburger, “Kinetic model for Integrin-mediated
adhesion release during cell migration,” Annals of Biomedical Engineering, vol. 27, 1999,
pp. 219-235.
27. D. A. Lauffenberger and A. F. Howritz, “Cell Migration: A physically integrated molecular
process,” Cell, vol. 84, 1996, pp.359-369.
28. G. Plopper, “The extracellular matrix and cell adhesion,” Cell, vol. 49, 2002, pp.123-143.
74
29. J. R. Hurley and D. A. Narmoneva, “Fibroblasts induce mechanical changes in the
extracellular environment and enhance capillary-like network formation,” Proceedings of the
ASME 2008 Summer Bioengineering Conference (SBC2008), June 2008.
30. R. J. Reynolds and J. A. Schecker, “Radiation, cell cycle, and cancer”, Las Alamos Science,
no.23, 2003, pp. 64 – 73.
31. D. Fufa, SparkNote on The Cell Cycle, SparkNotes, December 2008.
32. D. S. Goodsell, The Machinery of Life, Springer-Verlag, New York, 1998.
33. M. Gheorghe, M. Holocombe, and P. Kefalas, “Computational models of collective
foraging,” BioSystems, vol. 61, 2001, pp. 133-141.
34. M. Holocombe and A. Bell, “Computational models of immunological systems,” Information
Processing in Cells and Tissues, Plenum Press, 1998, pp. 213-226.
35. G. Booch, I. Jacobson, and J. Rumbaugh, “OMG Unified Modeling Language
Specification”, March 2003, page xxv.
36. B. Bauer, J. P. Muller, and J. Odell, “Agent UML: A formalism for specifying multiagent
interaction”, Agent-Oriented Software Engineering, Paolo Ciancarini and Michael
Wooldridge ed., Springer-Verlag, Berlin, 2001, pp. 91-103.
37. S. W. Ambler, The Object Primer: Agile Model Driven Development with UML2, 3rd ed.
Cambridge University Press, Cambridge, 2004, pp.231-236.
38. B. Bauer, “Uml Class Diagrams Revisited in the Context of Agent Based Systems”, AgentOriented Software Engineering II, Springer-Verlag, Berlin, 2002, pp. 101-118.
39. R. Dover and C. S. Potten, “Cell cycle kinetics of cultured human epidermal keratinocytes,”
Investigative Dermatology, vol. 80, no. 5, May 1983, pp. 423-429.
75
40. S. P. Palecek, A. Huttenlocher, A. F. Horwitz, and D. F. Lauffengurger, “Physical and
biochemical regulation of integrin release during rear detachment of migrating cells,”
Journal of Cell Science, vol. 111, 1998, pp. 929-940.
41. V. Vallurupalli and C. Purdy, “Agent based modeling and simulation of biomolecular
reactions,” Scalable Computing: Practice and Experience (SCPE), vol. 8, no. 2, 2006, pp.
185-196.
76
Appendix
User Manual – 3D Agent Based Model of Cell Growth
This appendix has been divided into the following sections
1. Installation of MASON
2. Installation of Eclipse
3. Setting up MASON with Eclipse
4. Running MASON
4.1 Running from Command Prompt
4.2 Running from Eclipse
5. Starting the Simulation
A.1. Installation of MASON
1. The homepage for MASON is http://cs.gmu.edu/~eclab/projects/mason/
2. The latest version of MASON (as of January 2009) is Version 13 and it can be found in
its homepage. MASON is available as a tar file as well as a zip file.
3. Extract the zip file and save the contents in a specific folder. For example, C:\MASON
4. Since we are more interested in developing MASON for 3D visualization, we need to
install Sun’s Java3D framework.
5. Java3D is available in http://java.sun.com/javase/technologies/desktop/java3d/index.jsp
77
6. MASON has the capability to draw charts and graphs based on the values generated from
the simulation. To extend this MASON feature, we need to add a separate library
(libraries.zip) available in the homepage of MASON.
7. Other online tutorials are available that have further details about MASON. These are
available at the link given below:
http://cs.gmu.edu/~eclab/projects/mason/
The basic requirements that are needed to install MASON and Eclipse would be a Pentium
processor or equivalent or higher, 512MB RAM or higher, Windows XP or higher, or Mac OS x
9 or higher.
A.2. Installation of Eclipse
1. Download Eclipse from http://www.eclipse.org/downloads/
2. Download the Eclipse Classic. The latest version is Eclipse Classic 3.4.1, as of January
2009. Download the file and install the IDE.
3. Create a workspace. Multiple workspaces can be created to work more efficiently.
A.3. Setting up MASON with Eclipse
1. Setting up MASON with Eclipse is an important step. Directions can be found at
http://www.swarm.org/images/1/10/How-to_set_up_%26_use_Eclipse_with_Mason.pdf
78
2. The above link has details on how to incorporate a package into the MASON
environment in Eclipse. Section IV in the document explains setting up MASON with
Eclipse.
A.4. Running MASON
MASON can be run in two ways. One is from the command prompt and other is from the Eclipse
IDE environment. Before running our model, the source code should be imported into MASON.
The following steps should be followed.
1. The source code is present as Skin.rar file. Extract the rar file into the MASON directory.
2. Right click on sim.app inside MASON and create a new package by name Skin.
3. Right click on the package Skin and then select Import  File System. Click Next, and
from here browse through the computer directory and select the source code which is
extracted in the MASON directory.
4. After importing, click on the tree in MASON and double click the files in sim.app.Skin to
view the source codes.
A.4.1 Running MASON from Command Prompt
1. From the command prompt, go into the folder where MASON is installed and then type
the following command – java sim.display.Console. This particular console window
has by default a set of simulations.
2. Typing in this command, will start this set of simulations. Each simulation can be started
by clicking on the simulation.
79
3. This set of default simulations is also embedded in the homepage of MASON.
A.4.2 Running MASON from Eclipse
1. Advice on running the model from Eclipse is available at the following website:
http://www.swarm.org/images/1/10/How-to_set_up_%26_use_Eclipse_with_Mason.pdf
2. Section V in the above link has details on how a model can be run from Eclipse.
A.5 Starting the Simulation
1. Inside Eclipse, expand the hierarchy tree that appears on the left of the screen.
2. Expand MASON  src  sim.app.Skin
3. Double click on sim.app.Skin.SkinWithUI.
4. To run the simulation, either press F5, or Click on Run  SkinWithUI.
5. The simulation windows will open up. The ways to start the simulation and the controls
in the dialogue boxes can be found in Chapter 4.
80