 Rhaen, rhaen, wedi bod Rhann Rhaen i arddangos i wneud am y mynd i sydd y tiddorell ymddangos. Rhaen, ar hwn o'n fathau o Hiphle, ac mae'n gwybod i gael siarad teknog dus i fynd i ddim yn ysaf. Rhyw i'r bobl hwn o'r bobl beir, yn ddos i ddim yn ysaf. Dyna'r gweithio i chi os yw lle o'r coul yma. Rwy'n ddim yn awdurdod o'r ddwyllion sydd wedi'i dysw y wneud o'r gweithi, eich cyffredin gyda ni na ei f番. O bobl ydych chi gyda'r cymryd yn gwybod ei amser o part achos Ym Gwyloedd Aysydd, gyda eu gwirioneddredd ydw i'n gwybod o gweithio mewn cyfr�edig mewn cyfr�edig i ffwrdd yw'r cyfr�edig, lle mae'n siosto sefydledd i gyfr�edig yn cael ei ddweud i gwybod i'r cyfr�edig, phas gilydd yma yn gweithio maysrig ac gweithio mewn cyfr�edig, ac mae'n digwydd y cerd yn yng Nghymru, èr cyfr�edig bwysig mewn cyfr�edig o rai amddun i ymgynghor 잠깐만au, I'm looking at collections of cells. So while that's similar to neurons, we're looking at systems where cells move, they divide and die, they interact with each other and the environment, and these are over time scales of hours and days and years. So it's a little bit different to what you've been doing. And the questions we're interested in are how individual changes on individual cells influence at the tissue level. So some of the biological systems we're looking at is looking at the epithelial layer in the colorectal crypt. So that's an application I'll talk a bit about later, that's on the left. Also looking at tissue engineering, in particular bone tissue engineering, and also biofilms, which is on the bottom right. So we've used it for these various applications, but the main one I'll talk about a bit later is the crypt. OK, so you've all talked about multi-scale modelling, but I thought I'd give you kind of my definition so I know where I'm coming from. So the reason we're interested in multi-scale modelling, as you all know, is that biological processes are intrinsically multi-scale. And even if you only care about what's happening on one scale, for example, a concentration of the nutrients throughout the tumour, how that evolves is going to depend on processes occurring on other spatial and temporal scales. So you need to consider these different scales when you make a model, which is basically what you've been saying all day, so that's grand. OK, so when we've started making out this framework, we worked out from the assumption that the fundamental unit of biology seems to be the cell. So basically you've taken a middle-out approach and got a framework where you've got cells at the central level. So in our model we have a discrete individual representation of a cell, so there's an idea of a cell. OK, and this cell has, you can kind of bury down inside of it and have an idea of what's happening at a sub-cell level, so sub-cell your machinery dictating what the cell's going to do, when it's going to divide, how it's going to move, how it's going to react. And then also this is all coupled to processes that are occurring on the tissue level. This could be the diffusion of nutrients, some kind of vasculature, and that would interact both with the cell level and also through concentrations inside the cell as well. So all these levels interact together. So as I said, the kind of main central component of the framework is the cell, and we have an individual model for a cell. So I'm quickly going to go through some of the sort of wave people of modelled cells. So what we want is we want to be able to explicitly consider an individual cell. We're going to be able to track its size, shape and movement, and we want the model to be able to have influences from above and below. So it needs to, whatever model you have for your cell, it needs to be able to react to what's happening inside of it and also outside of it as well. So there's four broad classes of models for this. There's a cellular automata model, a cellular POTS model, which are both on-lattice models which restrict cells to moving on-lattice, and I'll describe them in more detail in a minute. Then if we relax that assumption and we allow cells to move anywhere in space, then we get something called off-lattice models which are broadly reduced into two different categories of cell centre-based models and vertex models. So you've all probably seen the cellular automata model before, but I'll quickly go through it. So what we've basically got here is a cell. We break up our spatial domain where we want our cells to exist, where our tissue is, and then we can say each individual cell occupies one lattice side to this domain. So in this one, it's just a square of a grid. And when a cell wants to move or divide, it can move into an adjacent space. So it kind of moves a whole cell diameter at a time, which is a bit of a disadvantage. But following advantage is that it's very simple to implement. You can give it to a reasonably talented undergraduate student and give them a day if they know how to use MATLAB and they can code up pretty quickly. It's fast to run. It's all local movement, so it's not too bad. The cons are, as I said before, cells kind of have a thick size. They make these big jumps in movement. They can only ever exist at the sweet positions. One particular problem with basic cellular automata models is to say this cell, which is sort of highlighted with the areas divides and this grid goes all across the rule. If this one divides and wants to move left, it will shift the entire row of cells all along the wall. So you kind of get movement at a distance, which may not be realistic. There are ways around that, but they make the model more complicated. Also, depending on the neighbourhood you fix for your cells and also the shape of your grid, you can get an isotopic growth. So if you sort of say that cells can only move up, down, left and right, you'll end up getting sort of pyramid, sorry, diamond-shaped growths. And there are ways around that as well, but also that makes things more complicated. So one of the nicest sort of extensions is what's known as the cellular pots model, which comes from ferromagnetics originally. So what this basically does is it allows, it represents a cell. Instead of being one lattice site, you assume it's a collection of lattice sites as shown here. And then what you do to evolve this is you kind of pick two pairs of adjacent cells and you decide whether you want to switch them or move a cell in, or your cell wants to grow into that space. And you do that by calculating kind of a probability of that happening based on minimising something like this energy distribution at the bottom, then using Monte Carlo simulation. So these things sort of, the cells will sort of grow and fluctuate over time. What that sort of looks like is this, so it looks a little bit like Tetris. So you get lots of blocks of different coloured cells. And all the cells coloured in green or blue are the same, all the boxes coloured in the same colours are the same cell. And then that evolves by cells just switching colour, boxes, sorry, switching colour over time. So these are both the on lattice simulation types. So they're fine, they're quite quick to implement and they're relatively easy to use. But the problem is you've only ever got a finite number of conformations which isn't particularly realistic. So if we drop the assumption that cells have to lie on a lattice, we get this class of off lattice models. So the simplest of these is a cell centre model. So what we're doing is we're representing cells by a single point in space. Okay? And then we're evolving these based on certain rules. So we have to decide some kind of connectivity for these cells. So we could say cells are connected to their nearest neighbours which is not known as an overlap in spheres model. It's very similar to a dynamic simulation. So basically we draw a sphere around each of these points. And then those spheres, when they come into contact, they'll basically deform and they'll be a force which forces the cells away from each other. Cells can have different radii. They can also have different interactions between each other. So that's sort of an overlap in spheres model. Another way is to consider the region to be broken up into the Voronoi tessellation of your domain. So this sort of gives cells nice polygon shapes which is what you see if you're modelling epithelia which is one of our applications. So we quite often use this one. And then here you've got a jewel of this Voronoi tessellation which is the Lorne triangulation which dictates the domain. So basically you've got some kind of connectivity between cells and in between cells we place springs or some other force which means the cells are going to move. Because of this we're actually solving equations that kind of look like the equation on the bottom right. So for each cell we can work out the velocity, therefore we can evolve it over time. Now because of this we get a nice smooth motion, not the kind of jittery motion we had in the on lattice models. So it's a bit more advanced like that. We can also directly include different forces which can be measured on the cells. The downside is there's no kind of direct control of cell size. So while you can sort of dictate an interaction radius or spring stiffness and lengths like that, you can't actually explicitly say cells want to be maybe sort of long and thin sort of like that. So that's sort of a downside in this model. There is a small extension in this model known as a subcellular element method which instead of just having one point inside a cell, in one point representing a cell, it basically has a collection of points representing a cell. So you could have 10 points to represent a cell, then another 10 points to represent another cell and the forces between the cells, the points that are inside a cell have one particular form and then the forces intercellular forces have a different form. So you can end up getting different shapes like that. But fundamentally it's the same model down, underlying model. So you get, when you do that, you can look at things like this. So this is just an example of a growing spheroid. Each of these is an individual cell so it's a vulnerable region around a point in space. Okay, so as I said before, a lot of work we're looking at is looking at epithelial layers. When cells grow in an epithelium, they tend to take this polygon-like shape. So a model we like to use is a vertex model which is kind of a generalisation of that. It's kind of a generalisation of the POTS model but to an off-flatter approach. So instead of representing cells by their centres or points that live inside the cell, we represent cells by the vertices of a polygon. So as you can see here, this cell in the centre is represented by the six cells around it and those vertices are free to move instead of the centre of the cell. And what you do to evolve it is you're still solving just a velocity equals some force. But instead of defining the force explicitly, we can actually define it in some kind of potential here where this potential basically means a cell wants to be a certain target area, a certain target perimeter and have certain cell-cell interactions with a neighbouring cell. Okay, so you can include a lot more detail in these sorts of models saying cell-cell interactions, cell-cell adhesion, things like this. So it's a bit more advanced. But again, because it's more advanced, it's more computationally intensive. Okay? And so this is just a quick video of just a vertex model. So here we have cells that are dividing and dying and then merging with each other and leaving each other. So these are the sorts of simulations. So you're going to see a few more simulations like this. Okay, as we go through. That's just a simple toy example. Hmm? Yeah, so people have actually used vertex models and POTS models to model bubbles as well, but then they don't have birth. So it's a slightly different thing with it. A lot of the ideas are very similar. Okay, so that sort of dictates. We've now got our individual model for our cell. We can pick one of those or some variant of that. Then we need to dictate how a cell is going to grow and divide or any other interactions. So for this, we want to model the subcellular processes. So you could have something very simple like a cell divides every couple of hours or you can even add some stochasticity to that. So it's still just simple, really agent-based models. We could actually want to consider the cell cycle explicitly when a cell's in a particular phase, when it gets stuck in G1 phase, this sort of thing like that, or other metabolic pathways of what's going inside the cell. So these sorts of reaction networks that people code up in SBML and like this. Typically, what you end up with when you look at the mathematics of it is a system of non-linear ODE's which you want to solve inside each individual cell. Now, these ODE's could be coupled to some kind of extra-cellular concentration, for example, nutrient level or some kind of inhibitor that's floating around. That gets inside the cell, so these could affect these subcellular models. And so that's how they're influenced, but they can also influence the cell level model which you talked about a minute ago by dictating when the cell's going to divide, what sort of size or shape the cell wants to be, any changes to cell stromal or cell cell adhesion, also what kind of cell the cell's going to become if it differentiates, so what the cell's fate is. So these sort of influence the behaviour of that subcellular model. And then obviously we've got to consider the tissue level as well. So on this level we consider things like geometric constraints. So, as your growing tissue confines its lay in a certain domain, is it lying on another layer of cells that you're not considering and they have a certain shape, any imposed gradient. So are there any concentration gradients you know about that you can impose on here? Is there a vascular network? So, you know, vasculature is supplying blood to this region. We can also consider things like juxtaprine signalling. So cell A will signal to its neighbour's cell B that it's got a certain level of something like delta or notch and then the other one will react accordingly. And we could also consider just general field equation. So looking at the sort of diffusion of nutrients or inhibitors throughout the domain. Now of course the cell, all of these individual cells in your blob will be acting as syncs or sources depending on what you've got. So you're basically solving reaction diffusion PDEs with multiple syncs and sources on growing domains. So it's not completely trivial, but it's a relatively simple problem to do. We could also look at how cells react to fluid flow. So how cells react to pressure and shear stress. So things like mechanical transduction. So these are the sorts of tissue liver processes you may want to include. Okay, so when you put all that together you end up on the right with your kind of simulation. So this on the right is just a growing monolayer quite happily and it's got nutrient diffusing through it. So you could look at it on that level but then if you burrow down into that and look in a bit more detail you see an individual model where there's individual cells that are interacting. You can track all the properties of those cells and there's various rules for how they evolve but then inside each of those individual cells there's some kind of model for what the cell subcellular machinery of the cell and when the cell is going to divide all this kind of thing. So you can see you've at least got three different scales. So even if you're only interested in what's happening on a tissue level, so for example how big is your tumour? For example something like that. That's going to depend on what kind of model you've got here and how cells interact and also what's happening inside those cells. And of course there's lots of multiple different possible models at each scale. So how are we going to deal with all that? Okay, so that's kind of a brief overview of the mathematics side of the framework. I'm now going to introduce Chase and talk about how you go from this kind of mathematical model I've just described to a computational simulation. Okay, so what is Chase? So basically it's a library of numerical code that was developed in the Computational Biology Group in Oxford and some other people as well for solving problems in computational biology. So it was started in 2005 as a programming project for the integrative biology project. So there was about sort of eight or nine, I think, PhD students and a few postdocs, plus all the academics, plus the members of the computational biology groups. I think about 25 people at the time in total. All sat in a room for four weeks and tried to code, write some computer code that would solve electrical propagation in the heart and do a discrete model of tumour growth. So that was the aim for four weeks. They got quite far in four weeks and at the end of it a subset of those people kind of carried on sort of every week developing it a bit more. And those people have changed. So there's kind of been sort of, I would say, six odd regular developers all the way through. Initially the development was mainly on the cardiac side of things, but now it's sort of shifted and people doing the cell-based side of things and more PhD students. But that's now shifted and there's a bit more emphasis on the cell-based side of things. So there's sort of these iterate. So the way we develop it is there's sort of sessions every week where people come along and sit down and code in pairs. So the reason we code in pairs is because it's developed using something called extreme programming, which is basically a computer science, well, software engineering term for a way of developing code in a certain way that makes it robust and reliable. So all your code when you develop it you sit down with two people at a computer and code. So you make sure the code that goes in is been reviewed by somebody else. And the main way we develop it is something called test-driven development. So before you add some new functionality to the code, say new ODE solver, you write a test for it. So you'd write a test that you knew the answer to. You'd code that into the code, you'd try and run it and it would fail because it wouldn't solve it. Then you'd implement your functionality and then basically when you implement the functionality correctly your test would pass. And when you've done that you can submit everything to repository. So that way everything's kind of maintained and updated in central manner. And one advantage is where we test our code kind of continuously. So every time somebody commits a new change to repository, it's tested. All the tests are kept and run all the time. And also they're run nightly and weekly. So we know that every single line of the code is covered. So anything that's inside the source code has got to be tested somewhere by a test. So we know what it's doing. It's also tested for things like memory leaks and stuff like that as well. And also doxygen. So it's all got good documentation. So that's all kind of done. It slows you down a little bit to start with it. It means when you get to something with the amount of lines of code you've got, you can kind of get new developers to understand what's going on relatively easily. So what it kind of consists of is nearly half a million lines of code roughly spit between source code and tests. So the tests are quite important as you can see here. The majority of it is written in C++. So all the codes written in C++ but we use things like Python for actually doing all the build and doing some scripting. And it's open source release. It's just been really, well, it was initially released under an LGPL license. We've recently just changed that to a BSD license. So you can basically download it which is there's websites and kind of do what you want with it. But because of all these really quite anal development techniques we kind of achieve our aims and we've got this robust, easily extensible, reliable, reusable piece of code. So it still does, if you run a simulation in it and you publish it in a year's time you can go back and run rerun that exact simulation again and it works. It does the same thing. So which is quite an advantage really. Okay, so that's kind of chased in general. There were two main components to Kydec and the cell way side of things. Here's the website. You can find it by searching for chased on the internet but if you do it's about the sixth one down because there's lots of other funny websites before it. So just search for chased Oxford or something like that and you can find it and there's what it is. It's got all the stuff on the right and all the latest news. So I think the next side is users. So I think we've got around sort of two, three hundred users around the world using various different sides. Most of the users are using the Kydec side of chased because it's kind of more developed but we've still got quite a few using the cell based. It's not got anybody in Africa yet, unfortunately, and only one right in the middle of Asia. But yeah, but we've also got people who are using the Kydec side of things at the FDA and using the cell based things at NASA to sort of look at radiation and things like that. So it's being used quite a bit. Okay. So the structure of things. So I'm trying to keep the computer science down a little bit. But you know, it's fun to include it anyway. So the way chase is structured is kind of got this main core of code which is basically a big suite of libraries for solving ordinary differential equations solving partial differential equations doing input output that sort of thing. So the PDE classes are real. Oh, so linear algebra. So the linear algebra stuff is there's bits of it we've done ourselves but majority of that is actually signed of a wrapper around things like Pepsi and stuff like that. So we actually are using existing software where as possible because there's no point reinventing the wheel but it provides a nice interface to be able to use that. So that's kind of the core libraries. And then there are libraries which sort of add on the functionality to be able to do the sort of modeling I was talking about earlier which is a cell based side of things. And then there are further libraries which do kind of application specific one. So there's a folder called crypt which does application specific has applications specific libraries. And then on the other side of things there's a heart folder which does all the cardiac things. And then as a user you can actually have these individual user projects which we can kind of point at what you want to depend on. So you can depend on the cardiac side of things or the cell based side of things so it's quite flexible in that respect. Or if you wanted you could completely ignore both of those and just depend on the core stuff in the middle. Okay. So although this talk is about the cell based side of things I thought I'd quickly say what the point of the cardiac side of chase is. So the point of this is to simulate the propagation of electrical activity in the heart. So it's using things like Llewer-Roodi and all these kind of models for cardiac cells. And what it consists of is solving a couple of reaction diffusion PDEs on some kind of mesh. So on the right is a mesh that's got about four million nodes. So it's an anatomical mesh of a quadrant of the heart. So there is the whole mesh which is just a slice of visualisation. And these PDEs are solved these PDEs are coupled to ordinary differential equations at each of the nodes in this finite element mesh. And at each of these the PDEs represent kind of a cell model. So an electrical cell model and these are all encoded in cell ML. So this is quite a standard thing for doing in these heart models. And this is a system known as the bi-domain equations. And if you solve that what you're kind of looking at here is you sort of stimulate the bottom of the heart there and this wave of electrical activity moves through the heart. So that's basically what the cardiac side of chase does makes pretty waves like that. It's also beginning to look at electromechanics. So as this wave propagates through it will cause muscle cells to contract which actually causes the heart to beat. Okay, so they begin to look at that as well. So that's all I'm going to say about the cardiac side of things. If you've got any questions you can ask me at the end and I'll try and answer as best I can but I'm not the most knowledgeable person on this side of things. But in this case it's finite element modelling not representing cells but just representing cells? Yes, yes. So where it kind of... Yeah, so what it is is you break up your basically have a big mesh which a finite element mesh. Okay, and each node in that mesh you have what they call a cell model but obviously each node of the mesh isn't actually a cell. It's a collection of cells so it represents sort of an average of 100 cells or something like that. So you're solving a cell model on there which is meant to represent what's happening in an individual cell but you're kind of solving it in the homogenised sense. So what you do is you take... When you derive these by the main equations you kind of take a system where you have individual cells and then you homogenise it and then this is just an American approximation to the homogenised equations. How many elements do you have in... I'm not sure about that one but there's elements with sort of four million nodes and things like that. Not elements, I mean meshes with that sort of detail. And this is running in parallel now? So all the cardiac stuff, yeah. So this simulation I think was done running on Hector. So on multiple cores and things like that. Using MPI and... Yeah, so... ...cred. Yes, so all the parallel stuff so all the linear algebra is written using Petsy which uses MPI for its parallel communications. So all of the cardiac code we can actually run sort of in parallel on multi... on HPC and stuff like that. Cool. Okay. Right. Okay, so if you take sort of a step back a few slides I was talking about this cell based modelling and we had this frame where we had sort of individual cells with stuff inside them and stuff outside them and we wanted to model that. So how do we model that in Chase? Well what we basically do is we have a bunch of classes so we have a bunch of C++ classes to represent the individual elements of this model. So we have lots of objects that represents cell so we have an object of a cell we have lots of instances of this object this class sorry to represent a big collection of cells so we basically make each of these cells for initial conditions we associate each of these cells with some kind of subcellular model which is another class and then we collect all of these different cells into a cell population object which associates these cells with some kind of spatial information. So if that's a lattice it if that's a cell centre model it just represents it with a point in space if it's a cellular automaton model it represents it with a lattice site and then what we do is we plug this cell population into a simulation class which takes in things like forces, update rules, killers which dictate how the simulation progresses and then it runs. Okay so it's simple the reason it's done like this is because if you wanted to add a new functionality for example you wanted to add a new subcellular model you could just make a subclass of one of the existing subcellular models in there it would fit in and then you could just run it straight away. So all the simulations that I'm going to show you later on which are based on this on cell base case are actually run just by instantiating various different versions of these classes and plugging them together. Okay so the different functionality we have so we basically have all the sorts of things I was talking about earlier at the cell level we can do a o-lefin spheres, raw and o-cell centre model do vertex, pots or cellular automata. At the subcellular model we can do stuff ranging from a rule based cell cycle model through to ODE based cell cycle models or just a sort of a combination of the two so having a rule based model for birth and division but having system of equations for protein concentrations being solved as well and at the tissue level we can look at kind of external factors we can have this juxtaprind signalling between cells or we can look at solving PDEs on this growing domain. You don't do PDEs within the cell? No because the cells, I mean you could do that's not something we've looked at because at the minute we just have ODE's inside the cell but there's no reason why you couldn't have a subcellular model which had some because if you have a cell which is a certain shape you might want to have a higher concentration here than there so there's no reason you can't it's just not something we've needed for our applications at the moment. So that's probably a good point to note that the way we develop chast is whenever we have an application that requires a new functionality that's the only time we'll put that functionality in. We won't, we're not trying to make something that does everything. We're trying to make a piece of software that for a particular application if you need to add a new functionality you will add it and then you'll be able to use it for that and then if somebody else needs that functionality you may need to refact that in a certain way so that it can be used in more ways than one. So that's the way we do it. We try not to look we try not to look too far ahead and guess what we're going to need. Okay, so in order to set up a simulation you basically got to define a various number of things. So you basically got to define all these different objects on the right here and so you've got to define the type of cell model you want to use you've got to define how cells interact with each other so how they interact with themselves and also how they interact with any boundaries on there. You need to define a subcellular model how cells are going to proliferate, grow and die and also if there's any kind of diffusible species around and how they interact with cells and if there's any boundary conditions on those diffusible species when you decided what these are that dictates which of the various classes that are in chase that you want to plug together you then plug them together in this kind of way and run your simulation. Okay, so I'm now going to show you a couple of applications of this. So the first one is the colorectal crypt and so as I said before this is basically the way the lining of the gut is renewed. So you've kind of got your smaller nitrogen testin which is this sort of tube basically and all the way along this tube it's like someone stuck their fingers in play though so you've got these sort of test tube shaped invaginations in there so if you imagine on the picture on the right your gut is sort of going along as a cylinder like that and then what happens is cells at the base of these crypts sort of proliferate so I don't know if you can see it outside each of these yellow sticks is some sort of blue haze and the blue haze represents the cells. So these cells will proliferate and then migrate up the crypt and then they're removed off the top while they kind of form this epithelial sheet at the top and it's a really quite nice system to model because there's about 700 cells in each crypt which is quite a small manageable number. They renew themselves every two to three days. There's a hell of a lot of them inside you and so each crypt loses about 10 cells per minute so it's quite a quickly renewing system. So it's quite amenable to modeling so we want to look at kind of so the crypt is also the sort of site to the instigation of colorectal cancer so what happens is this lovely migration of cells from the base of the crypt to the top and then removed gets goes wrong because cells are going to mutate and they want to persist in the crypt so we're sort of interested in how that happens. So what we have here is I've taken one of these crypts and sort of unwrapped it so it's basically just like a 2D sheet so it represents sort of the unwrapped cylinder and then what we have here is cells proliferate depending on some kind of external queue so there's an external gradient of wind factors which is just all they really do is they do quite a few things but in terms of this simulation they just dictate when cells are going to divide or not. So cells towards the bottom of the crypt are yellow and they've got high levels of wind and they'll divide whereas cells at the top don't so you can imagine these cells at the bottom will proliferate and everything will move up quite happily and get removed off the top. What we've done is introduced some mutant cells in each of these so that the mutant cells no longer respond to the wind so they're going to keep proliferating. Okay so you can imagine this as one particular mutation that cells might have and on the right we've also added another mutation which means these cells are more adhesive to the stromal tissue so all these cells effectively sit on a layer of basal stroma which is effectively the whiteboard here. So as this thing runs you see the one on the left they proliferate and the black cells will keep proliferating but they'll get removed whereas on the right these cells will persist in the crypt. So it's basically looking at what cellular level properties will lead to kind of overcrowding. So here we're looking at whether a mutation will persist in the crypt. So what properties does a mutation have for it to need to persist in the crypt? Okay. So you can also see on this simulation on the right there's a hell of a lot of cells that are very cramped which is obviously not particularly biologically realistic and in reality these cells would no longer remain as a sheet that sort of buckle out and they'd become a blob like they'd become a polyp which is actually the early stages of cancer formation. So in order to model that correctly we've actually looked at a more advanced model where instead of just considering the cells to lay on a layer we're actually considering the 3D structure of these crypts. And so if you look at the this is some staining of the base of the crypt. So all these sort of things that look like golf balls are kind of the base of the crypt and the crypt goes this way. And so there's actually a structure that holds these crypts in a shape. Okay. So what we've done is we've used the modelling framework I've told you. We've introduced kind of the idea of having a basement membrane and what we've called an actin basket which is this base at the bottom. So have a domain where we have this one on the left where we basically have a layer of non-proliferating cells which are in green and then a layer of proliferating cells in yellow on top and there's actually kind of an imaginary basement membrane in between those which sort of dictates how bent this region wants to be. So if we run it here what we're sort of simulating is in this central region there's this actin basket that wants to support the base of the crypt and that then forms the crypt and you know you can kind of grow a crypt from a flat layer into this kind of shape. Then once we've grown a crypt we can then look at it in this region over here. So we've added a mutation but now you can actually see the surrounding cells can actually deform and make way. So when these cells get a bit too big you can actually see the crypt will grow. And take up more room and move the surrounding cells. So actually looking into a bit more detail what's happening. So that's sort of the crypt. So there's just a few more simulations just to sort of show the sorts of things we can do. So all of these are using the same sorts of classes just with slightly different settings. So here on the left we've now got a 3D version of this crypt and I've now coloured every single cell based on its ancestor. So all the blue cells here came from the same original progenitor cell. So if that cell had a mutation now the entire mutations would have taken over the crypt. So if we now just change some of the population boundary conditions it's basically about two lines of code in your simulation. You now have three moving cells in space. So this just represents kind of bacteria swarming around so they swim around but then they're sort of transient clustering. So when they get near to other cells they like to stay near them. There's still a certain chance that they'll move away. So that's effectively very similar to the simulation on the left. We've just changed on the left we've restricted cells to the line of surface on the right we've let them free to move. And then the bottom right so on the bottom left is the sphere what I showed you earlier. So here you've got just the population cells going out but we're actually solving a nutrient equation through this domain. So cells on the inside will have less nutrients so it will die. And on the right is on the bottom right is just a very quick example of juxtaprine signalling. So these cells aren't proliferating anything. They're just there's levels of delta and notch which are two proteins inside the cell and they're affected based on the surrounding medium values as well. So you get this sort of layering effect. So they're the sorts of simulations we're doing. So that's sort of a very quick overview of the sort of stuff we've done. What we're planning to do in the future is kind of extending the functionality of Chaste. We're looking at paralyzing these simulations. So although the heart code is completely paralyzed and scales very nicely the cell based code doesn't at present. So this is actually the work of a PhD student of mine Daniel Harvey who's working on that and has already got certain levels through it. So we're getting there. We're also looking at including extra cell level models. So I showed you these four different classes of models but each of them has got more subclasses. So we'd like to include some more of those. For example, finite element models where you actually have solid cells at the form. We're looking to include things like the vasculature on fluid flow in these models as well. Because at the minute we don't have those but they'd be very useful for various different applications including the vasculature would be good for looking at tumour therapy and the fluid flow is kind of needed for the tissue engineering application and the biofilms. So if you remember back to the second talk yesterday unfortunately I can't remember the speaker but it was the not second the third talk which was the one on the Skype. They were talking about looking at hybrid models where you've kind of got discrete representations of objects and a continuum representation to have this blending region. So that's the sort of thing we're also doing. So looking at if you have a growing tumour and you have cells not really doing a lot in the centre treating them with a continuum model but having a proliferating rim using discrete cells. And also modelling structures like extra cellular matrix or EPS which is the equivalent of extra cellular matrix for a biofilm looking to model that as particles. So you've kind of got cells and also other particles as well in your simulation. And also extending it to different applications for example looking at protein-protein interactions where instead of having the cell as a central unit you're kind of looking at proteins considering the motion of proteins in a bilayer using MD simulations as the kind of sub-cellular machinery. And sort of on the usability side of things we've done some work with MathWorks looking at trying to instead of having to run these simulations in C++ actually using MATLAB scripting to be able to run and visualise simulations in a simplified manner. We've also been developing tools a bit like V-cell where you can run your simulations through either an online portal or a Java app and then it will store your results in a big database for you and then there's kind of you can reuse all your results very sensibly. We're looking at trying to use initial conditions from data so at the minute we kind of have to hardcore the initial positions of our cells which is a bit of a downside but it'd be really nice to be able to actually take some images of these systems and sort of tag where different cells are and then use that as the initial condition for your simulation and probably what's more interesting to you lot and we're looking at using sort of markup languages to description of these models. So we're in quite a nice situation because we have multiple different so most people when they develop software to do this kind of multi-cell modelling they pick one particular type of cell modelling so the POTS model or a cell centre model and they run with that because of the fact that we've actually got a big collection of at least four of these different types of models in one place we're kind of very well set to be able to start using things like SBML to decide the sub-cell in the machinery and I've sort of made a, well I think it's a made-up name of multi-cell ML I think some people have said it before but having some kind of markup language to dictate how you relate these different cell level models to each other and how you would define say I want a simulation, I want a vertex simulation with this number of cells doing this thing or I want a cell centre simulation with this number of cells and that's I think all I have to say but it's like to thank the following people who are all kind of involved either now or at some point in development with Cell Based Chaste and various people who have funded it throughout its development so thanks very much