Mechanosensitive Cell Mechanics on Engineering Tissues

"Sometimes I had to work for 10-13 hours straight just to make some simple things working. The answer to those problems usually turns out to be something very simple. If I knew where the source of those problems was each and every time I got stuck, it would've taken less than 10 minutes to fix the thing"

As some of you may know already, I have been developing a computational framework for simulation of animal cell behavior on engineering tissues (or lattice as I frequently call it). It has been known that when animals cells are cultured on a flexible tissue, the direction at which the cells align is determined in such a way that principal stresses within the cell structures are minimized. 

A lattice can be mechanically constrained to exhibit some directional variation in its stiffness. Suppose there is a planar square lattice. If we fix - that is, constraint any movements of - any two opposite sides out of the total four sides, then one's intuition gives that the resulting lattice stiffness across the two fixed sides will be higher than the one in the opposite (orthogonal) direction. Indeed, our intuition is true and this is how we experimentally create a variation in lattice stiffness.

Since a cell has to minimize the principle stresses within itself, it will change its orientation. The net result is (I'm skipping over lots of details) a certain directional elongation of the cell boundary. In other words, cell boundaries show directional preferences to stiffness conditions on the lattice. 

The above picture is an example of a cell on a lattice in virtual environment. The two opposite boundaries of square lattice are fixed. Toward to the top left of the lattice, there is our beautiful cell growing whose outer and inner cell boundaries are clearly visible. The inner cell boundary marks where a nucleus is located. During the simulation, it is our assumption that the nucleus boundary does not move significantly. Therefore a constant inner boundary assumption is used. (The colors in the plot shows variations in the magnitude of lattice displacements)

The outer boundary, however, should exhibit different, but consistent, directional preferences depending on varying boundary conditions. The outer cell boundary is subjected to a uniform boundary force pointing inward along the focal adhesion boundary and, due to the non-symmetrical lattice boundary conditions imposed, this uniform force does not necessarily translate into a uniform strain distribution along the boundary. This is where I ask myself a question: how will it deform then?

Now, my Matlab code generates mesh and displacement data and integrates displacement vectors along radial directions with a uniform angular increment all around 360 degrees. This is done for all x, y, and z components such that at the end of the result we can have some graphical representation of how overall distribution of displacements along the focal adhesion boundary looks like. The non-uniform distribution of the planar displacements along the boundary clearly shows that there is indeed some preferences when it comes to the outer cell boundary deformations. The out-of-plane displacement (z-displacement) in the above graph shows that the cell is actually rising up to the direction normal to the upper planar lattice, due to the observed overall contraction of cell boundary (one can think of this in terms of the conservation of cell volume).

Just one thing quick though. The graph looks almost like an analytical result judging from the fact that the curves are so smooth and everything that there is no jumpy unexpectedness that usually arises as an artifact in typical numerical calculations single precision. But believe me, it was nothing like this smooth when the code was at its premature stage of the development and most of the time and effort has gone into making the result perfect and beautiful like the one above. This does not mean that I modified the numerical results to get smooth curves, but it is rather, through many numerical singularity correction algorithms applied differently each iteration steps and of course the algorithms themselves have been refined for months, corrections after corrections. There is no word that describes a programmer's feeling when, after several months of playing with non-sense results, everything just works all of sudden!

No comments: