The main strength of Morpheus is that it enables you to create multi-scale models concisely and simulate them efficiently.

In this post, I’ll show how to couple different model formalisms using symbols.

It is assumed you have a basic understanding of how models are described in Morpheus. If not, please go through the “Getting started” post first.

# A word on the word “multi-scale”

First, let’s clarify what we mean by the somewhat hyped term “multi-scale”.

Generally, the term refers to mathematical and computational models that simultaneously describe processes at **multiple time and spatial scales**. In contrast to the models based on the *quasi-steady state* assumption that discard interactions between scales, multi-scale models describe systems where processes at **different scales can influence each other**. Therefore, these models should not only simultaneously describe multiple scale, but also allow them to interact.

One fact that complicates this is that processes at different scales are often best formalized in different modeling formalisms. Therefore, multi-scale modeling often also involves **coupling different modeling formalisms** that may include spatial/nonspatial models, discrete/continuous models, stochastic/deterministic models.

## TL;DR

In short, multi-scale models are, for the purpose of this post, characterized by three features:

- they simultaneously describe
**multiple time or spatial scales** - they allow
**interaction between the scales** - typically involve
**coupling between model formalisms**

# Multi-scale models and middle-out

Morpheus deals with a particular type of multi-scale models for multicellular systems that consists of:

**intracellular**processes such as genetic regulatory networks, often modeled as ordinary differential equations,**cellular**processes such as motility or cell division, modeled in terms of cellular Potts model, and**inter/extra-cellular**processes such as production and diffusion of cytokines, modeled with reaction-diffusion systems.

Morpheus enables you to first model each of these systems separately as single-scale models and later flexibly combine these sub-models into multi-scale models. This allows you to include certain sub-models in a pragmatically fashion in which you start from a certain level of abstraction and work your way up and down by including crucial processes at different scales. Morpheus is designed to support this so-called middle-out modeling strategy.

# A multi-scale mini-model

Let’s go through an example. We’ll construct a model in which an

- intracellular cell cycle network (ODE) regulates
- the division of motile cells which (CPM)
- release a diffusive cytokine (PDE) which, in turn,
- controls the cell cycle (ODE).

Thus, there are 3 sub-models (ODE, CPM and PDE) that interact in a cyclic fashion:

- $ODE \rightarrow CPM$,
- $CPM \rightarrow PDE$,
- $PDE \rightarrow ODE$.

## Step 1: Intracellular model (ODE)

First, we define a ODE model of cell cycle that we take directly from [Ferrell et al. 2011].

This system describes three interacting species as variables $CDK1$, $Plk1$ and $APC$:

$$
\begin{aligned}
\frac{CDK1}{dt}&=\alpha_1 - \beta_1 \cdot CDK1 \frac{APC^n}{ K^n + APC^n} \\

\frac{Plk1}{dt}&=\alpha_2\cdot(1-Plk1) \frac{CDK1^n}{ K^n + CDK1^n } - \beta_2 \cdot Plk1 \\

\frac{APC}{dt}&=\alpha_3\cdot(1-APC) \frac{Plk1^n}{ K^n + Plk1^n } - \beta_3 \cdot APC
\end{aligned}
$$

In Morpheus, we can describe the same system of equations, together with the parameter values as below:

Note that the `System`

is now defined within a `CellType`

. This makes sure that the ODE system is calculated separately for each member of the population of this cell type. Also note that the variables are defined as `Properties`

. These are variable that are bound to a particular cell such that each cell can have a different value for this variable.

If you run this model for a single cell with the parameters above, you will see oscillatory behavior:

`Examples/ODE/CellCycle.xml`

to try yourself.
## Step 2: Cell-based model (CPM)

Now, we would like to couple the above model to control the “physical” cell division of a spatial cell model. This can be achieved easily by adding a few elements (highlighted in green in the figure below).

First, we add a `VolumeConstraint`

and `SurfaceConstraint`

that control the area and shape of a cell. And, obviously, we need to add a `CellDivision`

plugin that controls when and how a cell divides. Here, we specify that the cell should divide when `CDK1 > 0.5`

in the `Condition`

of cell division.

Note that the multi-scale coupling is automatically established by the symbolic reference (outlined in red) between the condition for cell division and the variable in the intracellular ODE system.

One additional thing to specify is what happens when cell division occurs, using the `Triggers`

. Here, we specify that the target volume `Vt`

of the two daughter cells is half the target volume of the mother cell, i.e. to model cleavage without cell growth.

This generates a simulation like this:

See `Examples/Multiscale/CellCycle.xml`

to try yourself.

## Step 3: Intercellular model (PDE)

The remaining two steps are (1) to let cells release a diffusive chemokine and (2) to make this chemokine modulate the cell cycle.

### Added a diffusive Field

First, let’s define a cytokine $g$ that diffuses with coefficient $D_g$, is produced by cells proportionally to its concentration $APC$ and decay linearly with a certain rate (0.05):

$$\frac{\partial g}{\partial t} = D_g{\nabla}^2g + APC - 0.05 \cdot g$$

In Morpheus, we define a `Field`

`g`

in the `Global`

section and specify the diffusion coefficient $D_g$ in `Diffusion/rate`

. The reaction step of is defined in the `System`

where we provide a `DiffEqn`

with the production and decay terms in the expression `APC - 0.05*g`

:

Note that we explicitly set `APC`

to be zero everywhere (`Constant APC=0.0`

) but this value is overwritten wherever there are cells (i.e. in the `CellType`

scope). This established the coupling between CPM and PDE: the movement and shape of CPM cells affect the production term in the PDE.

### Modulating cell cycle

Last step is to let the local concentration of the cytokine modulate the cell cycle.

We first need to compute the local cytokine concentration $g_l$ for each cell (plugins highlighted in green below). Since there are different possibilities (i.e. we could take the sum, the mean or the maximum concentration ‘under’ the cell), we need to use a plugin called a `Mapper`

in which we can define statistic we want to compute. Here, we specify the `Mapper`

to take Field `g`

as an input and assign the average value to the cell `Property`

`g_l`

– the local cytokine concentration.

Finally, we let the local concentration of $g$ affect the cell cycle dynamics. Here, we (quite artificially) assume that this concentration acts as an additional production term for $CDK1$ and add it to the `DiffEqn`

for `CDK1`

(see red outline). This implements the coupling between PDE and ODE: the extracellular cytokine concentration affects the intracellular cell cycle.

Here’s a video of a simulation of the full multi-scale model we constructed:

`Examples/Multiscale/CellCycle_PDE.xml`

to try yourself.
# Relative time-scales

At this point, you may be asking yourself “*All nice and well, but how can I control the relative time-scales between the various models?*”. And I’d respond: “*Great question!*”.

Morpheus has a number of ways to control the relative time-scales of the various sub-models. We can either control the ODE/PDE dynamics in `System`

or control the cellular dynamics in `CPM`

.

## Controlling ODE dynamics

Within the `System`

element, there is an optional attribute called `time-scaling`

. When set, all equations within the system are multiplied by this value. Therefore, it can be used to slow down or speed up the dynamics that the ODE system models. Note, however, that this may imply that you need to set a smaller `time-step`

to guarantee numerical stability.

For example, to speed up the cell cycle dynamics, we can set `time-scaling=2.0`

(compare with figure 2)

## Controlling CPM dynamics

Another way to control the relative timescale is by increasing or decreasing the dynamics of the CPM model. That is, we can control how long one CPM step takes in units of simulation time.

In `CPM/MCSDuration`

, we can set the duration of one Monte Carlo step (MCS) which is defined as one full CPM lattice update. For instance `CPM/MCSDuration value="0.01"`

means that Morpheus computes 100 MCS per uint simulation time.

# Conclusion

In this post, we have constructed a small multi-scale model in which an ODE model, a CPM model and a PDE model are mutually coupled to each other. The main aim was to show how one can couple such models with relative ease in Morpheus and how you can control such couplings.

I hope this will enable you to create your own models!