Compartmental models of growing neurites (Graham and van Ooyen 2004)

 Download zip file 
Help downloading and running models
Accession:59582
Simulator for models of neurite outgrowth. The principle model is a biophysical model of neurite outgrowth described in Graham and van Ooyen (2004). In the model, branching depends on the concentration of a branch-determining substance in each terminal segment. The substance is produced in the cell body and is transported by active transport and diffusion to the terminals. The model reveals that transport-limited effects may give rise to the same modulation of branching as indicated by the stochastic BESTL model. Different limitations arise if transport is dominated by active transport or by diffusion.
References:
1 . Graham BP, van Ooyen A (2004) Transport limited effects in a model of dendritic branching. J Theor Biol 230:421-32 [PubMed]
2 . Graham BP, van Ooyen A (2006) Mathematical modelling and numerical simulation of the morphological development of neurons. BMC Neurosci 7 Suppl 1:S9 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Axon; Dendrite;
Brain Region(s)/Organism:
Cell Type(s):
Channel(s):
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: Java;
Model Concept(s): Development;
Implementer(s): Graham, Bruce [B.Graham at cs.stir.ac.uk];
/* ADTree.java

Implements "diffusion + active transport" model of branching
  - branching due to concentration of branching chemical C in terminal tip (growth cone)
    - production in soma
    - decay in soma and growth cone
    - diffusion along growing neurite
    - active transport along neurite
  - section-level model
    - conc. measured in fixed volume at end of every neurite
      section (unbranched length of neurite)
      - volume specified by length dL
    - two new branches of length minL and containing no
      chemical are created on branching
      
Version 1.0 BPG 29-3-03
  - implements model as described in Graham and van Ooyen, 
    Journal of Theoretical Biology 230:421-432, 2004
  
*/

import java.lang.Math;
import java.util.Random;


// New tree class
public class ADTree extends Tree {

  // New class variables
  static float Kbr=1.0f;  // scale factor for branching probability
  static float dt=1.0f;  // time step
  static float dL=1.0f;  // length step
  static float minL=5.0f;  // min diffusion length
  static float a=0f;	// active transport rate
  static float D=1.0f;  // diffusion constant
  static float ICbr=1.0f;  // production rate
  static float gsCbr=1.0f; // soma uptake rate
  static float gtCbr=1.0f; // terminal uptake rate
  static float somaL=1.0f;  // soma length
  static float somadiam=1.0f;  // soma diameter
  static float termdiam=1.0f;  // terminal node diameter
  static float ebp=1.0f;  // branch power for diameter
  static float Vel=1.0f;  // elongation phase growth rate
  static float Vbr=1.0f;  // branching phase growth rate
  static float crate=1.0f;	// mean elongation rate
  static float rCV=1.0f;  // coefficient of variation of rates
  static double Tbstop=1.0f;  // branching stop time
  static int ntot=1;	// total number of terminals in growing tree

  // data entry
  public static String DEparams[][] = {
    {"Branching scale factor (Kbr):", "0.01925", "0.01925"},
    {"Diffusion rate (D):", "0", "0"},
    {"Active transport rate (a):", "100", "100"},
    {"Soma production rate (I):", "10", "10"},
    {"Soma uptake rate (G0):", "9", "9"},
    {"Terminal uptake rate (Gn):", "100", "100"},
    {"Conc. calc. length (dL):", "1.0", "1.0"},
    {"Minimum length (minL):", "5.0", "5.0"},
    {"Branching phase rate (Vbr):", "0.22", "0.22"},
    {"Elongation phase rate (Vel):", "0.51", "0.51"},
    {"Rate coefficient of variation (rCV):", "0.28", "0.28"},
    {"Time branching stops (Tbstop):", "264", "264"},
    {"Soma length:", "10.0", "10.0"},
    {"Soma diameter:", "10.0", "10.0"},
    {"Terminal diameter:", "1.0", "1.0"},
    {"Branch power (e):", "8", "8"}};
  public static final int Nparams=16;

  // random number generators for branching and elongation
  static Random ranG=null;  // Gaussian random number
  static Random ranp=null;  // Uniform random number
 
  // Instance variables
  float Cbr;	// conc. of branch-producing chemical
  float Cbrp;	// value at previous time step
  float erate; // variation in elongation rate



  // Constructor for cell body
  public ADTree(int key, int order) {
    super(null, key, order, somaL, somadiam);  // basic tree constructor
    
    ranp = new Random();  // randomness for branching
    ranG = new Random();  // randomness for elongation rates
    
    updateParams();  // get parameter values from data entry
    Cbr = ICbr/(gsCbr+gtCbr);  // steady-state initially
    Cbrp = Cbr;
    crate = Vbr;  // branching phase mean elongation rate
    erate = (float)ranG.nextGaussian();  // new variation
    // must have positive growth
    while((rCV*crate*erate) + crate <= 0)
      erate = (float)ranG.nextGaussian();  // new variation
    
    // add first neurite segment as left branch
    this.ltree = new ADTree(this, key+1, Cbr);
    Tree.brkey = key+2;  // reset branch key
  }


  // Constructor for first neurite branch
  public ADTree(Tree parent, int key, float Cinit) {
    super(parent, key, 0, minL, termdiam);  // basic tree constructor
    Cbr = Cinit;  // no branching chemical initially
    Cbrp = Cbr;
    erate = (float)ranG.nextGaussian();  // new variation
    // must have positive growth
    while((rCV*crate*erate) + crate <= 0)
      erate = (float)ranG.nextGaussian();  // new variation
  }


  // Constructor for new branch
  public ADTree(Tree parent, int key, int order) {
    super(parent, key, order, minL, termdiam);  // basic tree constructor
    Cbr = 0;  // no branching chemical initially
    Cbrp = Cbr;
    erate = (float)ranG.nextGaussian();  // new variation
    // must have positive growth
    while((rCV*crate*erate) + crate <= 0)
      erate = (float)ranG.nextGaussian();  // new variation
  }


  // Constructor for single compartment (continuation of branch)
  public ADTree(Tree parent, int key, int order, float erate) {
    super(parent, key, order, minL, termdiam);  // basic tree constructor
    Cbr = 0;
    Cbrp = Cbr;
    this.erate = erate;  // parental variation
  }



  // Get parameter values from data entry (class method)
  public static void updateParams() {

    Kbr = Float.valueOf(DEparams[0][2]).floatValue();
    D = Float.valueOf(DEparams[1][2]).floatValue();
    a = Float.valueOf(DEparams[2][2]).floatValue();
    ICbr = Float.valueOf(DEparams[3][2]).floatValue();
    gsCbr = Float.valueOf(DEparams[4][2]).floatValue();
    gtCbr = Float.valueOf(DEparams[5][2]).floatValue();
    dL = Float.valueOf(DEparams[6][2]).floatValue();
    minL = Float.valueOf(DEparams[7][2]).floatValue();
    Vbr = Float.valueOf(DEparams[8][2]).floatValue();
    Vel = Float.valueOf(DEparams[9][2]).floatValue();
    rCV = Float.valueOf(DEparams[10][2]).floatValue();
    Tbstop = Double.valueOf(DEparams[11][2]).floatValue();
    somaL = Float.valueOf(DEparams[12][2]).floatValue();
    somadiam = Float.valueOf(DEparams[13][2]).floatValue();
    termdiam = Float.valueOf(DEparams[14][2]).floatValue();
    ebp = Float.valueOf(DEparams[15][2]).floatValue();

  }


  // Set time step (class method)
  public static void setTimeStep(float dt) {
    ADTree.dt = dt;
  }



  // Randomly branch all terminal nodes
  public void branchTree(double t) {
    // new segments start with length minL
    // concentrations measured in volume of length dL at
    // end of each segment

    float Td=0, Ta=0;  // diffusive and active transfer

    // Diffusion and active transport
    
    // diffusion into segment
    if (parent == null) {  // soma
      if (ltree.length >= minL)
	     Td = ltree.diam*ltree.diam*(ltree.getValue("Cbrp") - Cbrp) / (((length-dL)/2)+ltree.length); 
    }
    else if (parent.parent == null && length >= minL) {  // parent is soma
      Td = diam*diam*(parent.getValue("Cbrp") - Cbrp) / (((parent.length-dL)/2)+length);
    }
    else if (length >= minL) {
      Td = diam*diam*(parent.getValue("Cbrp") - Cbrp) / length;
    };
    
    // diffusive transfer into child branches
    // (all compartments have length at least minL)
    if (parent != null) {  // not soma
      if (ltree != null)
        if (ltree.length >= minL)
	       Td = Td - (ltree.diam*ltree.diam*(Cbrp-ltree.getValue("Cbrp"))/ltree.length);
      if (rtree != null)
        if (rtree.length >= minL)
	       Td = Td - (rtree.diam*rtree.diam*(Cbrp-rtree.getValue("Cbrp"))/rtree.length);
    };
    
    // active transport to children
    if (parent == null)  // soma
      Ta = -Cbrp*ltree.diam*ltree.diam;
    else if (parent != null && ltree != null) // not soma or terminal
      Ta = -Cbrp*(ltree.diam*ltree.diam + rtree.diam*rtree.diam);

    // active transport from parent
    if (parent != null) // not soma
      Ta = Ta + parent.getValue("Cbrp")*diam*diam;
    
    // calculate new concentrations
    Td = Td / (diam*diam*dL);
    Ta = Ta / (diam*diam*dL);
    Cbr = Cbrp + (dt*((D*Td)+(a*Ta)));

    // Production
    if (parent == null)  // soma
      Cbr = Cbr + (dt*(ICbr-(gsCbr*Cbrp)));  // production - decay
      
    // Decay
    if (ltree == null && rtree == null)  // terminal
      Cbr = Cbr - (dt*gtCbr*Cbrp);  // decay
      
    if (Cbr < 0) Cbr = 0;  // cannot have negative concentrations
    
    // Randomly branch terminal node (during branch phase only)
    if (t <= Tbstop && ltree == null && rtree == null) {
      if (Cbr*Kbr*dt >= ranp.nextDouble()) {
        this.ltree = new ADTree(this, Tree.brkey++, order+1);
        this.rtree = new ADTree(this, Tree.brkey++, order+1);
      };
    }
    else {  // search for terminals to branch
      if (ltree != null) ltree.branchTree(t);
      if (rtree != null) rtree.branchTree(t);
    };
      
  }



  // Elongate terminal nodes
  public void elongateTree(double t) {

    // Check for elongation phase (soma only)
    if (parent == null) {
      if (t > Tbstop) crate = Vel;  // elongation phase
      else crate = Vbr;  // branching phase
    };

    // Elongate terminal nodes
    if (ltree == null && rtree == null) {
      length = length + (((rCV*crate*erate) + crate) * dt);
      }
    else {  // search for terminals to elongate
      if (ltree != null) ltree.elongateTree(t);
      if (rtree != null) rtree.elongateTree(t);
    };
    
  }



  // Set segment diameters
  public void diamTree(double t) {

    if ((ltree == null && rtree == null) || ebp == 0) 
      return;  // diameter already set
    else {
      if (ltree != null) ltree.diamTree(t);
      if (rtree != null) rtree.diamTree(t);
      if (parent != null) { // do not adjust soma!
        float diamp = diam;
        diam = termdiam*(float)Math.pow((double)countTerminals(),(double)(1/ebp));
        Cbr = Cbr * ((diamp*diamp) / (diam*diam));
        Cbrp = Cbrp * ((diamp*diamp) / (diam*diam));
      };
    };

  }



  // Update previous concentration values
  public void updateTree(double t) {

    Cbrp = Cbr;
    if (ltree != null) ltree.updateTree(t); 
    if (rtree != null) rtree.updateTree(t); 
      
  }



  // Get parameter value
  public float getValue(String vname) {

    if (vname.equals("Cbr"))
      return Cbr;
    else if (vname.equals("Cbrp"))
      return Cbrp;
    else
      return 0f;

  }


}

Loading data, please wait...