Rhesus Monkey Layer 3 Pyramidal Neurons: Young vs aged PFC (Coskren et al. 2015)

 Download zip file   Auto-launch 
Help downloading and running models
Accession:168858
Layer 3 (L3) pyramidal neurons in the lateral prefrontal cortex (LPFC) of rhesus monkeys exhibit dendritic regression, spine loss and increased action potential (AP) firing rates during normal aging. The relationship between these structural and functional alterations, if any, is unknown. Computational models using the digital reconstructions with Hodgkin-Huxley and AMPA channels allowed us to assess relationships between demonstrated age-related changes and to predict physiological changes that have not yet been tested empirically. Tuning passive parameters for each model predicted significantly higher membrane resistance (Rm) in aged versus young neurons. This Rm increase alone did not account for the empirically observed fI-curves, but coupling these Rm values with subtle differences in morphology and membrane capacitance Cm did. The predicted differences in passive parameters (or other parameters with similar effects) are mathematically plausible, but must be tested empirically.
Reference:
1 . Coskren PJ, Luebke JI, Kabaso D, Wearne SL, Yadav A, Rumbell T, Hof PR, Weaver CM (2015) Functional consequences of age-related morphologic changes to pyramidal neurons of the rhesus monkey prefrontal cortex. J Comput Neurosci 38:263-83 [PubMed]
Model Information (Click on a link to find other models with that property)
Model Type: Neuron or other electrically excitable cell;
Brain Region(s)/Organism:
Cell Type(s): Neocortex V1 L2/6 pyramidal intratelencephalic GLU cell;
Channel(s): I Na,t; I A; I K; I M; I h; I K,Ca; I Calcium; I_AHP;
Gap Junctions:
Receptor(s):
Gene(s):
Transmitter(s):
Simulation Environment: NEURON;
Model Concept(s): Influence of Dendritic Geometry; Detailed Neuronal Models; Action Potentials; Aging/Alzheimer`s;
Implementer(s): Weaver, Christina [christina.weaver at fandm.edu];
Search NeuronDB for information about:  Neocortex V1 L2/6 pyramidal intratelencephalic GLU cell; I Na,t; I A; I K; I M; I h; I K,Ca; I Calcium; I_AHP;
/
CoskrenEtAl2015
HHmodel
models
README.html
cad.mod *
cal.mod
cat.mod
hcurrent.mod
k2.mod
ka.mod
kahp.mod *
kc.mod
kdr.mod
km.mod
kvz_nature.mod *
mar.mod
max.mod
naf.mod
nap.mod
naz_nature.mod *
origlen.mod *
pass_wRel.mod
peak.mod *
shunt.mod
skahp.mod
Voffset.mod
vsource.mod *
aniruddha_young10axon.hoc
coskren_make_gui.hoc
fixnseg.hoc
init.hoc
linear_conductances_traub.hoc
main_CoskrenEtAl_extTraub.hoc
make_gui.hoc
make_gui2.hoc
mosinit.hoc
readcell_nomechanisms.hoc
scaleRm_aug3f.hoc
screenshot.png
Vkeep.ses
                            
/* Parses a cell specification file implemented as a hoc template.
   It is assumed that dendritic sections are named "dend.*[n]".  If the global
   flag_spines is set to 1, then any explicit spines (whose names match the
   pattern "spine.*[n]") are counted on each section, and then used to adjust the
   section's length and diameter according to the normalization procedure
   discussed in Guy Major's PhD thesis.
     Regardless of the setting of flag_spines, all explicit spines are then
   deleted, and tree properties set according to the passive properties
   defined at the top of this file.

   Expected globals:
     E_PAS: default value for the e_pas membrane variable

   Arguments:
     $1: the index of the cell to read.
 */

printf("Loading readcell_nomechanisms.hoc\n")

// *** Globals ***

ApicalHeadDiam = .47
ApicalHeadLen = .71
ApicalNeckDiam = .19
ApicalNeckLen = .44
BasalHeadDiam = .56
BasalHeadLen = .82
BasalNeckDiam = .16
BasalNeckLen = .54

SurfaceAreaOneApicalSpine = (ApicalNeckDiam * PI * ApicalNeckLen + \
                             ApicalHeadDiam * PI * ApicalHeadLen)
SurfaceAreaOneBasalSpine = (BasalNeckDiam * PI * BasalNeckLen + \
                            BasalHeadDiam * PI * BasalHeadLen)
VolumeOneApicalSpine = \
    PI * (ApicalNeckDiam/2.0) * (ApicalNeckDiam/2.0) * ApicalNeckLen + \
    PI * (ApicalHeadDiam/2.0) * (ApicalHeadDiam/2.0) * ApicalHeadLen
VolumeOneBasalSpine = \
    PI * (BasalNeckDiam/2.0) * (BasalNeckDiam/2.0) * BasalNeckLen + \
    PI * (BasalHeadDiam/2.0) * (BasalHeadDiam/2.0) * BasalHeadLen

/*
 * Applies spines to a cell on all dendrites matching the provided forsec
 * pattern.  The
 * global variable flag_spines is ignored, since this method only makes sense
 * to call when spine processing is desired.
 *
 * Arguments:
 * $1: "forsec" pattern describing the dendrites in the tree.
 */
proc applySubtreeSpecificSpines() { local total_surface_area, dend_surface_area, \
    surface_area_one_spine, spine_surface_area_for_section, surface_area_all_spines \
    localobj dendrite_pattern, each_section
  dendrite_pattern = new String($s1)
  surface_area_one_spine = $2
  dendrite_count = 0
  total_surface_area = 0
  surface_area_all_spines = 0
//  printf("Dendrite pattern: %s\n", dendrite_pattern.s)
  forsec dendrite_pattern.s {
    each_section = new SectionRef()

    dendrite_count = dendrite_count + 1
    temp = area(0.5)
    num_spines_in_section = 0
    for i = 0, (each_section.nchild - 1) each_section.child[i] {
      if (issection("spine.*")) {
        num_spines_in_section = num_spines_in_section + 1
      }
    }

//printf("Spine count = %d\n",num_spines_in_section)
    dend_surface_area = 0
    for (x) {
      dend_surface_area = dend_surface_area + area(x)
    }
    total_surface_area = total_surface_area + dend_surface_area
    spine_surface_area_for_section = (surface_area_one_spine * num_spines_in_section)
    surface_area_all_spines = surface_area_all_spines + spine_surface_area_for_section

    if (dend_surface_area > 0 && num_spines_in_section > 0) {
      factor = (dend_surface_area + spine_surface_area_for_section) / dend_surface_area
      L = L * (factor^(2/3))
      for (x) {
        diam(x) = diam(x) * (factor^(1/3))
      }
    }
  }
//  forsec "spine" { delete_section() }

  printf("Dendrite_count: %d\n", dendrite_count)
  printf("Total surface area before spine correction: %f\n", total_surface_area)
  printf("Total surface area of spines: %f\n", surface_area_all_spines)
  printf("Total surface area after spine correction: %f\n", \
         surface_area_all_spines + total_surface_area)
}

/*
 * Loads a cell, replaces the spines with the Major spine correction factor.
 * Note that this function destroys all sections, and creates the neuron from
 * scratch.
 *
 * Arguments:
 * $1: Path to neuron
 * $2: 1 if apical spine parameters should be assumed, 2 if basal spines,
 *     3 if both should be present, depending on whether the sections are
 *     named dend_apical* or dend_basal*.  (Clients should be aware of the
 *     implication: argument values 1 and 2 should only be used for partial,
 *     not whole, neurons.)
 * $3 Ra (NEURON predefined variable) to be applied to all compartments
 * $4 cm (NEURON predefined variable) to be applied to all compartments
 */
proc readcell() { local ra_arg, cm_arg localobj sref
  strdef neuron_name
  neuron_name = $s1
   printf("Loading neuron: %s\n", neuron_name)
  spine_type = $2
printf("readcell_nomech:  STD_SOMA = %g, spine_type = %d\n",STD_SOMA,spine_type)
  ra_arg = $3
  cm_arg = $4
  if (ra_arg == 0) {
    print "Error in readcell: Ra not specified."
    quit()
  }
  if (cm_arg == 0) {
    print "Error in readcell: cm not specified."
    quit()
  }

  // Clear out anything that was hanging around already, since it might
  // interfere with the simulation.
  forall { delete_section() }

  // It is required that the .hoc file loaded here will leave the soma section
  // as the currently accessed section.
  load_file(neuron_name)
  if (0 != strcmp(secname(), "soma")) {
    print "Error in readcell: loaded neuron did not access its soma"
    quit()
  }


  diam = 2.0 * STD_SOMA
  L = 2.0 * STD_SOMA

//  geom_nseg(500, 0.001)  // nseg according to frequency
  geom_nseg(500, 0.01)  // nseg according to frequency

  // Just for the soma.  Also reset diam and L, in case the change in nseg
  // disrupted them.
  nseg = 1
  diam = 2.0 * STD_SOMA
  L = 2.0 * STD_SOMA

  // geom_nseg depends on the values of Ra and cm for its work.  Since NEURON used to define these
  // as globals, but now defines them as section variables, play it safe by defining them both ways.
  cm = cm_arg
  Ra = ra_arg
  forall cm = cm_arg
  forall Ra = ra_arg
//  geom_nseg(500, 0.01)  // nseg according to frequency
//  geom_nseg(500, 0.1)  // nseg according to frequency

  // Ensure that NEURON evaluates the cell in 3D mode when calling diam(), by
  // using a side effect of the area() call.  It doesn't matter which section
  // is used for the call, and the return value of area() can be discarded.
  forall {
    area(0.5)
  }

  define_shape()

  surface_area_one_spine = -1
  volume_one_spine = -1
  if (spine_type == 3) {
    applySubtreeSpecificSpines("dend_apical", SurfaceAreaOneApicalSpine)
    applySubtreeSpecificSpines("dend_basal", SurfaceAreaOneBasalSpine)
  } else {
    if (spine_type == 1) {  // Apical
      printf("using apical spines\n")
      surface_area_one_spine = SurfaceAreaOneApicalSpine
      volume_one_spine = VolumeOneApicalSpine
    } else if (spine_type == 2) {
      printf("using basal spines\n")
      surface_area_one_spine = SurfaceAreaOneBasalSpine
      volume_one_spine = VolumeOneBasalSpine
    } else if (spine_type == 4 ) {			// added by cmw, 1/16/14.  omit spines
	  forsec "spine" {  delete_section() }		// added by cmw, 1/16/14.  omit spines
    }else {
      printf("ERROR: unrecognized spine type\n")
    }

    totalSurfaceArea = 0
    spineSurfaceArea = 0
    spineVolume = 0

/** added as part of mBPAP calculations **/
    // Baseline for distance is set at the midpoint of the soma, where both of
    // the dendritic trees are attached.  (This is identical to what's used by
    // the functions that compute L_out, L_in, and mbpap.
    distance(0, 0.5)

    // Preserve pre-spine correction distances
    forall {
      insert origlen
      for(x) {
        distance_origlen(x) = distance(x)
        length_origlen(x) = area(x) / (diam(x) * PI)  // area = l*pi*d
      }
      insert max
    }
/** end:  added as part of mBPAP calculations **/

    if (flag_spines == 1) {  // Global
      forsec "dend" {
        temp = area(0.5)
        sref = new SectionRef()
        num_spines_in_section = 0
        for j = 0, sref.nchild-1 sref.child[j] {
          if (issection("spine.*")) {
            num_spines_in_section = num_spines_in_section + 1
          }
        }

        SurfaceAreaDend = 0
        volumeDend = 0
        for (x) {
          SurfaceAreaDend = SurfaceAreaDend + area(x)
        }
        totalSurfaceArea = totalSurfaceArea + SurfaceAreaDend
        SurfaceAreaAllSpines = (surface_area_one_spine * num_spines_in_section)
        spineSurfaceArea = spineSurfaceArea + SurfaceAreaAllSpines
        spineVolume = spineVolume + (volume_one_spine * num_spines_in_section)

        if (SurfaceAreaDend > 0 && num_spines_in_section > 0) {
          factor = (SurfaceAreaDend + SurfaceAreaAllSpines) / SurfaceAreaDend
          L = L * (factor^(2/3))
          for (x) {
            diam(x) = diam(x) * (factor^(1/3))
          }
        }
      }
    }
    // Print some summary info for tables 1 and 2
    printf("\n")
    // Technically, this is the surface area *before* spine correction.
    printf("surface area: %g\n", totalSurfaceArea)
    printf("spine surface area: %g\n", spineSurfaceArea)
    printf("spine volume: %g\n", spineVolume)
  }  // spine_type != 3
  forsec "spine" {  delete_section() }
}

Loading data, please wait...