Edit on GitHub

The CellBasedModels.jl package aims to help fast-designing and simulation of agent-based models whith possibilities to be run in CPU and NVidia GPUs for the efficient computation of large-scale systems.

The following methods can be implemented in the model:

  • ODEs
  • SDEs
  • Division
  • Death
  • Coupling to continuum models evolving with PDEs
  • Random events

Check the Examples to get an idea of the capabilities of the package.

Installation

Hopefully, soon we will make an official release in the Julia repository. For now, you can install the package from Github as:

julia> using Pkg
julia> Pkg.add(https://github.com/dsb-lab/CellBasedModels.jl)

or from the Pkg REPL

pkg> add https://github.com/dsb-lab/CellBasedModels.jl

Examples

Patterning

Implementation of a patterning model as described by Corson et al. (2017). In this example you learn how to:
  • Write a full model from scratcht.
  • Using external functions in your model.
  • Deal with periodic boundary conditions.

ICM Development

Implementation of the development and commitment of the Inner Cell Mass of the embryo as proposed by Saiz et al. (2020). In this example you learn how to:
  • Use predefined models as base for more complex models.
  • Extract data from the Community object.
  • Making division events.
  • Fit agent based models to data using the Fitting module.

Particle Aggregation
Implementation of brownian particles with addesion properties and chack the aggregation transition. In this example you learn how to:
  • Write a full model from scratch and extend it.
  • Modifying global parameters.
  • Define boundary conditions.

Bacterial Colony Growth

Implementation of a bacterial interaction and growth model as described by Volfson et al. (2008). In this example you learn how to:
  • Use predefined models as base for more complex models
  • Working with non-spherical agents.
  • Making division events.

Bacterial Chemotaxis

Modification of the bacterial interaction model as described by Volfson et al. (2008) to be active bacteria with tumble-and-run dynamics and chemotaxis behavior. In this example you learn how to:
  • Use predefined models as base for more complex models
  • Working with non-spherical agents.
  • Work with models coupled with a medium.

Current Limitations

At the present stage of development, the library is not capable of working on batches of data. That means that the size of the simulated models will be limited by the memory disponibility in RAM or the GPU, depending on the platform in which the simulations are being tested.

Moreover, we can only use GPUs from NVidia as the GPU implementation is based on CUDA.jl.

Future work

We intend to extend the current version of the package with additional capabilities. Any help is welcome!

Short term

  • Addition of coupling to continuum systems.
  • Additions of inactive agents to make arbitrary shape boundaries.
  • Add more examples
  • Increase the number of implemented models.

Long term goals

  • Extend GPU capabilities to be used also in other packages.
  • Make optimization methods distributable among different CPU/GPUs.

Alternatives to CellBasedModels.jl

Many different packages and programs have been developed for constructing agent-based models.

Non-Julia-based specific software:

  • NetLogo is mostly focused on discrete dynamics. It is a bit outdated.
  • Mason Developed in Java, it is discrete-step-based software.

Non-Julia-based generic software:

  • ya||a Software developed with CUDA/C++. It is fast as it is fully parallelized but apart from already written models, that are specific for the study of limb morphogenesis, advanced knowledge of CUDA and C++ is required for any customization.
  • Mesa is developed in Python with a very intuitive framework. It is specialized in discrete dynamics in grid spaces.

Julia-based generic software:

  • Agents.jl. To our knowledge, there is only one alternative package written in Julia for the construction and deployment of agent-based models. It is a mature library and is the way to go for agent-based models in Julia for discrete-time dynamics. As another agent-based library, our library and the Agent.jl library overlaps in some of the capabilities and both can construct models in continuous space with similar capabilities. We focus our library on the simulation of continuous spaces with a continuous time that is described in terms of differential equations with the added value of being able to escalate the system to large amounts of agents by simulating in CUDA.