In this tutorial, we will show how to use a simple implementation of the contact inhibition cell-cycle model,
which prevents a cell from undergoing division when its volume is smaller than a critical value.
We first consider two mesh-based populations in 2D with cells trapped in a square box. In the first population,
all the cells are contact inhibited and we study the effect of the critical volume upon the global cell density. In the
second population, we consider a mix of ’normal’ cells (contact inhibited) and ’tumour’ cells (not inhibited) and study the growth of the
tumour cells within the box.
We then go on to consider the behaviour of a vertex-based population in a box that experiences contact inhibition.
This header needs to be included here to ensure archiving of CelwiseData works on all Boost versions.
The next header includes the Boost shared_ptr smart pointer, and defines some useful
macros to save typing when using it.
The next header include the NEVER_REACHED macro, which is used in one of the methods below.
The next header file defines the contact inhibition cell-cycle model that inherits from AbstractCellCycleModel.
The duration of the G1 phase depends on the deviation from a ’target’ volume (or area/length in 2D/1D): if a cell’s volume is
lower than a given fraction of its target volume, the G1 phase continues.
This model of cell-cycle progression allows for quiescence imposed by transient periods of high stress, followed by relaxation. Note that
in this cell cycle model, quiescence is implemented only by extending the G1 phase. Therefore, if a cell
is compressed during G2 or S phases then it will still divide, and thus cells whose volumes are smaller
than the given threshold may still divide.
The target volume and the critical fraction are specified using the methods SetEquilibriumVolume() and SetQuiescentVolumeFraction() respectively.
Within the ContactInhibitionCellCycleModel’s UpdateCellCyclePhase() method these parameters are compared to the actual cell volumes, which are stored
using the cell property CellData.
The next header defines the simulation class modifier corresponding to the contact inhibition cell-cycle model.
This modifier updates the CellData cell property at each timestep with the volume of each cell.
The remaining header files define classes that will be also be used and are presented in other tutorials.
We first define the global test class that inherits from AbstractCellBasedTestSuite.
Testing healthy cell contact inhibition with mesh-based population#
In this first test we show how to simulate the behaviour of cells healthy cells trapped in a box.
Each cell will only divide if there is sufficient room.
We use the honeycomb mesh generator to create a honeycomb mesh and
the associated mutable mesh.
We now create a vector of cell pointers.
We then define the mutation state of the cells we are working with. We will just consider
wild type mutations here.
We now create a cell-cycle (only contact inhibited) model for these cells and loop over the
nodes of the mesh to create as many elements in the vector of cell pointers as there are
in the initial mesh.
We now create a cell population, that takes several inputs: the mesh (for the position); and
the vector of cell pointers (for cycles and states)
In order to visualize labelled cells (i.e. those that are inhibited from division) you need to use the following command.
Here we create a simulation as before. We also set up the output directory, the end time and the output multiple.
Then, we define the modifier class, which automatically updates the volumes of the cells in CellData and passes it to the simulation.
Next, we create a force law (springs) to be applied between cell centres and set up a
cut-off length beyond which cells stop interacting. We then pass this to the VolumeTrackedOffLatticeSimulation.
To study the behaviour of the cells with varying volume, we trap them in the square domain [0,2.5]x[0,2.5].
This is implemented using four PlaneBoundaryCondition objects.
These planes are indicated by a point and a normal and then passed to the VolumeTrackedOffLatticeSimulation.
The domain is chosen to be quite small so as to make the test run in a short amount of time.
First we impose a wall at x=0:
Then we impose a wall at x<=2.5:
Then we impose a wall at y>0:
Finally we impose a wall at y<2.5:
To run the simulation, we call Solve().
To visualize the results, open a new terminal, cd to the Chaste directory,
then cd to anim. Then do: java Visualize2dCentreCells /tmp/$USER/testoutput/TestContactInhibitionInBox/results_from_time_0.
We may have to do: javac Visualize2dCentreCells.java beforehand to create the
java executable.
You will notice that once the cells are below a certain size they no longer proliferate and turn dark blue in the visualisation.
Testing normal and tumour cells with mesh-based population#
We now test the behaviour of a mixture of healthy and tumour cells in a Box. In this test healthy cells will only
divide if there is sufficient room whereas tumour cells will divide regardless.
Just as before we create a simple mesh.
We again create the cells. The difference here is that one of the cells is not contact-inhibited, but rather
is defined by a UniformCellCycleModel.
We now create a cell population, that takes several inputs: the mesh; and
the vector of cell pointers
In order to visualize labelled cells (i.e those that are inhibited from division) you need to use the following command.
Here we create a simulation as before. We also set up the output directory, the end time and the output multiple.
Then, we define the modifier class, which automatically updates the volumes of the cells in CellData and passes it to the simulation.
Next, we create a force law (springs) to be applied between cell centres and set up a
cut-off length beyond which cells stop interacting. We then pass this to the VolumeTrackedOffLatticeSimulation
As in the previous test, we trap the cells in the square domain [0,2.5]x[0,2.5]:
Finally, to run the simulation, we call Solve().
To visualize the results, open a new terminal, cd to the Chaste directory,
then cd to anim. Then do: java Visualize2dCentreCells /tmp/$USER/testoutput/TestContactInhibitionTumourInBox/results_from_time_0.
We may have to do: javac Visualize2dCentreCells.java beforehand to create the
java executable.
You will notice that once the healthy cells (yellow) are below a certain size they no longer proliferate and turn dark blue in the visualisation.
Whereas Tumour cells (light blue) on the other hand will continue to proliferate. You may want to run the simulation for longer to see this more clearly.
Testing contact inhibition in vertex-based monolayer#
We now test the behaviour of normal contact inhibited cells for a vertex-based population.
The example we use is a growing monolayer.
First we create a simple 2D MutableVertexMesh.
We then create cells as before, only this time we need one per element. We also create the cell population (a VertexBasedCellPopulation).
Here we create a simulation as before. We also set up the output directory, the end time and the output multiple.
Then, we define the modifier class, which automatically updates the volumes of the cells in CellData and passes it to the simulation.
Next, we create a force law, NagaiHondaForce, to be applied to vertices.
We then pass this to the VolumeTrackedOffLatticeSimulation.
In order to model cell growth between divisions, we add a SimpleTargetAreaModifier
to the simulator.
To run the simulation, we call Solve().
To visualize the results, open a new terminal, cd to the Chaste directory,
then cd to anim. Then do: java Visualize2dVertexCells /tmp/$USER/testoutput/TestVertexContactInhibition/results_from_time_0.
We may have to do: javac Visualize2dVertexCells.java beforehand to create the
java executable.
You will notice that once the healthy cells (yellow) are below a certain size they no longer proliferate and turn dark blue in the visualisation.
If you run the simulation for a long time these cells occur primarily towards the centre of the monolayer.