{
 "metadata": {
  "name": "",
  "signature": "sha256:1889ae534f956f32624c02e522e8e5297f5e9d774edf3b710640080737c63479"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "#Biofilm Model\n",
      "\n",
      "###Defining the Model\n",
      "Biofilms are clusters of bacteria cells that grow together on surface, creating a three dimensional film-like matrix, but little is known about what environmental conditions are needed for them to form. For my project, I hope to use an ABM to explore what environmental factors are necessary in order to create a biofilm.  \n",
      "\n",
      "###Goal\n",
      "My main question would be to discover the main environmental/growth factors that can alter biofilm formation, as well as to determine correlation functions between similar cells and cross-correlation functions between different types of cells. I believe this question can be answered by an ABM, since all my cells have similar features, but each act as their own agent. \n",
      "\n",
      "###Justification\n",
      "Using an ABM, I will be able to control different environmental factors by creating them as a different set of agents and bring all my agents together in my model to see how they interact.\n",
      "\n",
      "###Processes and Mechanisms of Interest\n",
      "I am interested in discovering what concentration of nutrients helps the cells to have the ideal growth. Obviously, more nutrients will help the cells grow, but if there are too many the cells will not adhere and form a biofilm. My goal is to run my simulation with different amounts of inital nutrients and also possibly different rates of replenishing the nutrients, corresponding to different media used to grow my cells in (inital nutirents) and also how quickly the cells can break down the nutrients in the media (rate of replenished nutrients). By changing amount of nutrients provided to the cell, I hope to determine the ideal amount of nutrients to grow a biofilm. \n",
      "\n",
      "###Outline\n",
      "For an individual run:\n",
      "   * Initalize a set amount of cells so they do not overlap\n",
      "   * Initalize a set amount of nutrients \n",
      "   * Pick a cell and see if it is close to nutrients\n",
      "       * If it isn't, continue (maybe make the cell die a little? After multiple checks with no nutrients?)\n",
      "       * If it is, have radius grow by 1\n",
      "           * If it is surrounded on 3 of 4 sides by nutrients, the cell will 'die' and be taken from the simulation- essentially there are too many nutrients and there is no reason for the cells to clump and form a biofilm \n",
      "       * Check radius, if above a max radius, have cell divide\n",
      "       * Record cell positions\n",
      "   * Add 1 to sweep count, repeat for next cell/next sweep\n",
      "   \n",
      "After a set amount of steps (or all cells are dead), I will check to see a visual representation of what the grid of cells looks like as well as record their positions. From that information, I should be able to find correlation functions for the variables. Below is a breakdown of some of the specifics of the model   "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "from __future__ import print_function\n",
      "import copy\n",
      "from math import *\n",
      "import sys\n",
      "import random\n",
      "import string\n",
      "\n",
      "import numpy \n",
      "import matplotlib.pyplot as plt\n",
      "import pandas\n",
      "import seaborn; seaborn.set()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 52
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "####I. Space\n",
      "Consider the space to be a 2D square grid for now. (Ideally, it will eventually be a 3D grid.) Possibly an overlay of 2 different 2D grids- This way one grid will be for the cells and the other grid will be for the nutrients. It will be very large in x, but discontinous at the boundries. Also for the y direction it should be large enough that it never reaches the top. For right now, I am only looking at one grid, but by my final model, hopefully I can have these 2 grids.\n",
      "\n",
      "####II. Model \n",
      "#####A. Parameters\n",
      "Based on my plans for the model, the follow parameters are needed:\n",
      "   * gridX- length of the 2D grid\n",
      "   * gridY- height of the 2D grid, much larger than gridX\n",
      "   * numCells- intial number of cells to place at time 0\n",
      "   * concentrationNutrients- inital amount of nutrients to place at time 0 as a concentration compared to numCells\n",
      "   * numNutrients- intial number of nutrients, product of numCells and concentrationNutrients\n",
      "   * isOccupied- True or false based on whether or not a cell is already in the grid at that space\n",
      "   * cellList- a list (dictionary?) that keeps track of the x and y position of each cell at each time step. This list can be used to both visualize my grid/biofilm and the positions can be used for correlation functions\n",
      "   * nutrientList- same as cellList, except it keeps track of the nutrients \n",
      "   * cellSpace- the representation of the cell grid\n",
      "   * nutrientSpace- the representation of nutrients on the grid\n",
      "\n",
      "#####B. Functions\n",
      "  * Constructor- set up parameters/grid values\n",
      "  * setupSpace- initalize the cellSpace and nutrientSpace\n",
      "  * createCells- initalize cells onto cellSpace, based on numCells set in constructor\n",
      "  * createNutrients- initalize nutrients onto nutrientSpace, based on numNutrients set in constructor\n",
      "  * findCell- return the cells x and y position in the grid\n",
      "  * countNutrients- call find Cells, see if there are nutrients on/around the cell grid space and count them\n",
      "  * cellSplit- Divide the cell into two, with the second cell going to a position in the Moore neighborhood around the cell\n",
      "  * step- go through the list of cells, see if a cell should grow/divide/die, place new nutrients\n",
      "  * correlationFunction- after all the steps, run this function to figure out the correlaton fucntion\n",
      "    \n",
      "   ** I think I need some plotting function, but I'm not sure what yet- look at that as one of the next steps once I get this code to work\n",
      "   \n"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class biofilmModel(object):\n",
      "    '''Model class, what will be executed with one run of the Biofilm model'''\n",
      "    def __init__(self, gridX = 30, gridY = 100, numCells = 10, concentrationNutrients = 0.4):\n",
      "        '''model constructor'''\n",
      "        # set up grid info\n",
      "        self.gridX = gridX\n",
      "        self.gridY = gridY\n",
      "        \n",
      "        #initalize info for the cells/nutrients\n",
      "        self.numCells = numCells\n",
      "        self.concentrationNutrients = concentrationNutrients\n",
      "        self.numNutrients = int(self.numCells*self.concentrationNutrients)\n",
      "        self.cellList = []\n",
      "        self.nutrientList = []\n",
      "        \n",
      "    \n",
      "    def setupSpace(self):\n",
      "        '''set up our grid space based on the self.gridX and self.gridY given'''\n",
      "        self.cellSpace = numpy.full((self.gridY, self.gridX), numpy.nan)\n",
      "        self.nutrientSpace = numpy.full((self.gridY, self.gridX), numpy.nan)\n",
      "        #print(self.cellSpace)- error checks, don't need to print every time\n",
      "        #print(self.nutrientSpace)\n",
      "            \n",
      "    def createCells(self):\n",
      "        '''Place cells in grid, number of cells corresponding to self.numCells'''\n",
      "        for x in xrange(self.numCells):\n",
      "            #check that there is an empty space? Otherwise this will be an infinite loop- DONE\n",
      "            isOccupied = True\n",
      "            cell.cellID = x\n",
      "            if self.numCells > self.gridX:\n",
      "                print('Too many cells- cannot place them')\n",
      "                return\n",
      "            else:\n",
      "                while isOccupied == True:\n",
      "                    self.cellList.append(cell(self))\n",
      "                    locY = 0\n",
      "                    locX = numpy.random.randint(0, self.gridX)\n",
      "                    cell.locationX = locX\n",
      "                    cell.locationY = locY\n",
      "                    #print(locX, locY)\n",
      "                    #print(self.cellSpace[locY][locX])\n",
      "                    if numpy.isnan(self.cellSpace[locY, locX]):\n",
      "                        isOccupied = False\n",
      "                    else:\n",
      "                        isOccupied = True\n",
      "            #cell.color = cellColorDecide()\n",
      "            self.cellSpace[cell.locationY, cell.locationX] = cell.cellID\n",
      "            \n",
      "    def createNutrients(self):\n",
      "        '''Place nutrients in grid, number of nutrients corresponding to self.numNutrients\n",
      "            Initalize nutrients along 1st and second row- right by the cells'''\n",
      "        for x in xrange(self.numNutrients):\n",
      "            isOccupied = True\n",
      "            nutrient.nutrientID = x\n",
      "            while isOccupied == True:\n",
      "                self.nutrientList.append(nutrient(self))\n",
      "                locY = numpy.random.randint(0, 2)\n",
      "                locX = numpy.random.randint(0, self.gridX)\n",
      "                nutrient.locationX = locX\n",
      "                nutrient.locationY = locY\n",
      "                #print(locX, locY)\n",
      "                #print(self.nutrientSpace[locY][locX])\n",
      "                if numpy.isnan(self.nutrientSpace[locY, locX]):\n",
      "                    isOccupied = False\n",
      "                else:\n",
      "                    isOccupied = True\n",
      "            self.nutrientSpace[nutrient.locationY, nutrient.locationX] = nutrient.nutrientID\n",
      "\n",
      "    def findCell(self, cellID):\n",
      "        '''Return cell position'''\n",
      "        # Find the value that matches cellID in self.cellSpace, then reshape to a 2-element list.\n",
      "        return numpy.reshape(numpy.where(m.cellSpace == cellID), (1, 2))[0].tolist()\n",
      "    \n",
      "    def countNutrient(self, y, x, distance=1):\n",
      "        ''' Return where nutrients are- need the cell location, use this to figure out if there are nutrients by the cells'''\n",
      "        nutrientCount = 0\n",
      "        #growth is related to how many nutrients are around the cell- keep track of how many we have \n",
      "        neighborPosition = [ ( y % self.gridY, x % self.gridX)\n",
      "                                for y, x in itertools.product(xrange(y-distance, y+distance+1),\n",
      "                                xrange(x-distance, x+distance+1))]\n",
      "        neighbor_list = []\n",
      "        nutrientPosition = []\n",
      "        for pos in neighborPosition:\n",
      "            #if we go off the grid make sure it doesn't return an error\n",
      "            if pos[0] < 0 or pos[0] >= self.gridY:\n",
      "                pass\n",
      "            elif pos[1] < 0 or pos[1] >= self.gridX:\n",
      "                pass\n",
      "            else:\n",
      "                nutrientPosition += [(pos[0],pos[1])]\n",
      "        for pos in nutrientPosition:  \n",
      "        # Check if empty\n",
      "            if not numpy.isnan(self.nutrientSpace[pos[0], pos[1]]):\n",
      "                neighbor_list.append(int(self.nutrientspace[pos[0], pos[1]]))\n",
      "                nutrientCount +=1\n",
      "        return neighbor_list, nutrientCount\n",
      "    \n",
      "    def cellSplit(self, y, x, radius):\n",
      "        '''Split the cell into two, with the new cell moving to one of the moore positions'''\n",
      "        #figure out what to do if the neighborhood if full. Move all cells? \n",
      "        newRadius = radius/2.0\n",
      "        radius = newRadius\n",
      "        #Place a new cell\n",
      "        #check that there is an empty space? Otherwise this will be an infinite loop\n",
      "        isOccupied = True\n",
      "        cell.cellID = len(self.cellList)\n",
      "        neighborPosition = [ ( y % self.gridY, x % self.gridX)\n",
      "                                for y, x in itertools.product(xrange(y-distance, y+distance+1),\n",
      "                                xrange(x-distance, x+distance+1))]\n",
      "        while isOccupied == True:\n",
      "            self.cellList.append(cell(self))\n",
      "            pickSpace = numpy.random.randint(0, len(neighborPosition))\n",
      "            #print(locX, locY)\n",
      "            #print(self.cellSpace[locY][locX])\n",
      "            if numpy.isnan(self.cellSpace[pickSpace[0], pickSpace[1]]):\n",
      "                isOccupied = False\n",
      "            else:\n",
      "                isOccupied = True\n",
      "        cell.locationY = pickSpace[0]\n",
      "        cell.locationX = pickSpace[1]\n",
      "        cell.radius = radius\n",
      "        self.cellSpace[cell.locationY, cell.locationX] = cell.cellID\n",
      "        # Work on this code- figure out how to move some of the cells if they are dividing but have a full Moore neighborhood\n",
      "        \n",
      "        \n",
      "\n",
      "    def step(self):\n",
      "        ''' see if a cell should grow, see if a cell should split or die, replenish nutrients'''\n",
      "        for cell in self.cellList:\n",
      "            cellPosition = findCell(cell)\n",
      "            nutrients = countNutrient(cellPosition[0], cellPosition[1], distance = 1)[1]\n",
      "            #check that there are nutrients either at the cell position or in the moore neighborhood of the cellPosition\n",
      "            if nutrients > 0:\n",
      "                cell.radius += 1\n",
      "                #make this be an increase based on the nutrients around the cell.\n",
      "                #get rid of the nutrients that are used? Use pop? \n",
      "            else:\n",
      "                #for a speicifc cell with no nutrients, it cannot grow- add one to that cell's noGrowthCount\n",
      "                #if noGrowthCount equals cellDeathCount, cell will die/remove it from the grid\n",
      "                cell.noGrowthCount +=1\n",
      "                if cell.noGrowthCount == cell.cellDeathCount:\n",
      "                    #set the position in our grid to a nan again- cell dies- Do I need to remove the cell from cell list?\n",
      "                    self.cellSpace[cell.locationX, cell.locationY] = nan\n",
      "                    \n",
      "        for cell in self.cellList:\n",
      "            if cell.radius > cell.maxRadius:\n",
      "                #split the cells if there are enough nutrients\n",
      "                nutrientAmount = countNutrient(self, cellPosition[0], cellPosition[1])\n",
      "                if nutrientAmount > 2:\n",
      "                    cellSplit(cellPosition[0],cellPosition[1],cell.radius)\n",
      "        \n",
      "        # Want my step to return my grid to me/my cellList and maybe my nutrientList- possibly in a results folder. Then use \n",
      "        # this to graph and/or run my correlation function\n",
      "                \n",
      "    \n",
      "    def correlationFunction(self):\n",
      "        '''Take the positions of the cells (from cell list) at the end of the sweeps and find relevant correlation fucntions'''\n",
      "        ##Figure out what correlations I'm looking for. Talk to Dr. Wood about this...\n",
      "\n",
      "\n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 106
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "####III. Actors\n",
      "#####A. Cells\n",
      "The cell class represents E. Faecalis, which I am modeling as circles. Each cell should be initialized with their specific set of parameters:\n",
      "   * radius- Their starting radius, a generated random number from a set minimum and set maximum radius\n",
      "   * colorDecide- Cells will either be red or green, again randomly chosen with the color assigned based on whether the random number is greater or less than a set number (50% off to start, may change depending on the system I want to simulate). I also plan on starting them with the ability to set one group of cells red and the other group green to see how the cells move and diffuse as they grow\n",
      "   * maxRadius- Set maximum radius a cell can have. Once the cell reaches this radius or greater, it either needs to divide or die\n",
      "   * locationX- The x position on the grid where the cell is, will update with each time step\n",
      "   * locationY- The y position on the grid where the cell is, again will update with each time step\n",
      "   * noGrowthCount- For each time step the cell does not grow (ie nearNutrients == False), the count will increase by 1. When the count reaches too high (the cell has not had nutrients for a certain amount of time) the cell will die\n",
      "   * cellDeathCount- compare noGrowthCount to this: if they are equal, the cell will die since it has not had nutrients in too long of a time period\n",
      "   * color- cell color, either red or green. Set to green, use the function color decide to see if it changes\n",
      "   * cellID - number of the cell, used to keep track of which one is where in the cell list\n",
      "\n",
      "  \n",
      "#####B. Nutrients\n",
      "For the cells to be able to grow, there need to be nutrients for them. In acutal biofilms, an extracellular matrix arises where the cells share their nutrients. To try to mimic this, I plan to initalize the nutrients initally randomly between the inital cells. As the cells grow and consume the nutrients, the nutrients will be replenished at some standard rate assuming there are still cells in that area. I am still trying to figure out the best way to distribute more nutrients as the cells grow/expand.\n",
      "   * locationX and locationY- Same as above for the cells, the place on the grid where the nutrients are placed\n",
      "   * nutrientID - number of the nutrient, used to keep track of which one in the nutrient list\n",
      "\n",
      "####IV. Initial Conditions\n",
      "#####A. Cells\n",
      "   * At time 0, ten cells will be intially placed in our grid\n",
      "   * All cells initialized with a locationY of 0, since they need to start on my substrate\n",
      "   * The locationX will be chosen randomly from the length of the grid\n",
      "   * Similarly, radius will be chosen randomly between the min and max radius\n",
      "   * Each cell will be assigned a color- red or green- based on the random number. This color will not effect how the cells interact, but rather show how cells move by being able to track the colors\n",
      "   * All cells will originally set nearNutrients to False and noGrowthCount to 0- until the first time step where they check to see if they are close to nutrients\n",
      "  \n",
      "#####B. Nutrients\n",
      "   * At time 0, after the cells are placed, nutrients will be randomly distributed based along the first few rows. \n",
      "  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class cell(object):\n",
      "    '''\n",
      "    Cell class, each individual cell acts as its own agent\n",
      "    Initalize all cells with similar basic parameters- the maximums for certain variables are consistent among the cells \n",
      "    even if specific cells have different size radius or nutrient counts\n",
      "    '''\n",
      "    \n",
      "    def __init__(self, model, maxRadius = 2.5, cellDeathCount = 10, noGrowthCount = 0, \n",
      "                locationX = 0, locationY = 0, color = \"green\", cellID = 0):\n",
      "        \"\"\"\n",
      "        Constructor for cell class.  By default,\n",
      "          * starts at origin of grid\n",
      "          * cell color is green\n",
      "          * random radius, with a max radius of 2.5\n",
      "        \"\"\"\n",
      "        self.model = model\n",
      "        self.radius = numpy.random.normal(0.5,1.5)\n",
      "        self.color = color\n",
      "        self.maxRadius = maxRadius\n",
      "        self.cellDeathCount = cellDeathCount\n",
      "        self.noGrowthCount = noGrowthCount\n",
      "        self.locationX = locationX\n",
      "        self.locationY = locationY\n",
      "        self.cellID = cellID\n",
      "    \n",
      "    def cellColorDecide(self):\n",
      "        ''' Change cell color- 50% of cells green, 50% red- change to red from defaulted green if colorDecide >=50%'''\n",
      "        self.colorDecide = numpy.random.normal(0,1)\n",
      "        if self.colorDecide >= 0.5:\n",
      "            self.color = \"red\"\n",
      "    \n",
      "    def getPosition(self):\n",
      "        ''' Return where in the grid this specific cell is'''\n",
      "        return self.model.findCell(self.cellID)\n",
      "        \n"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 107
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "class nutrient(object):\n",
      "    '''Nutrient class, randomly distributed throughout cells to help them grow'''\n",
      "    def __init__(self,model, locationX = 0, locationY= 0, nutrientID = 0):\n",
      "        \"\"\"\n",
      "        Constructor for cell class.  By default,\n",
      "          * starts at a randomly generated x and y\n",
      "          * always set nutrient placed to True \n",
      "          ***Figure out a way to set the x and y of where the nutrient placed is to true?\n",
      "          Maybe put this in the createNutrients function in the model? Also need to create nutrients if as the cells grow\n",
      "        \"\"\"\n",
      "        self.locationX = locationX\n",
      "        self.locationY = locationY\n",
      "        self.nutrientID = nutrientID"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 108
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "model = biofilmModel()\n",
      "model.setupSpace()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 109
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "model.createCells()\n",
      "model.createNutrients()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 110
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "print(model.cellSpace[0])\n",
      "print(model.nutrientSpace[0])\n",
      "print(model.nutrientSpace[1])\n",
      "#check to see where cells are placed, where nutrients are placed"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "[ 27.   8.  16.   5.  12.  10.  29.  23.  14.  28.   6.  20.   4.   0.  25.\n",
        "  19.   2.  17.  22.  11.  18.  15.  24.  13.   3.  26.   1.   7.  21.   9.]\n",
        "[ nan  nan  nan  nan  nan  nan  nan   1.   5.  nan  nan  nan  nan   3.  nan\n",
        "  nan  nan   0.  nan  nan  nan  nan  nan   6.  nan   9.  nan  nan  nan  nan]\n",
        "[ nan  nan  nan  nan   7.  11.  nan  nan   8.  nan  nan  nan  nan  nan  10.\n",
        "  nan   4.  nan   2.  nan  nan  nan  nan  nan  nan  nan  nan  nan  nan  nan]\n"
       ]
      }
     ],
     "prompt_number": 111
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "###Results \n",
      "####Overview\n",
      "Once this program is finished, I hope to be able to examine how biofilms grow in the presence of different concentrations of nutrients=[0.0, 0.2, 0.4, 0.6, 0.8, 1.0]. Once I know the idea nutrient concentration, I plan to also scan through different ratios of red to green cells and see how or if the cells diffuse. I plan to have plots showing the different growth at each concentration as well as correlation fucntions when looking at the ratios of the red to green cells.\n",
      "\n",
      "####Hypothetical Results\n",
      "As the nutrient concentration increases, I expect to see an increase in biofilm growth as there becomes enough nutrients to grow. This should be followed by a decrease when the concentration becomes to high- with a high amount of nutrient I expect the cells to no longer clump and begin to grow to quickly to form a biofilm. As far as the different colored cells, I do not expect them to diffuse and expect there to be a very low cross correlation."
     ]
    }
   ],
   "metadata": {}
  }
 ]
}