Source code for hnn_core.cell

"""Establish class def for general cell features."""

# Authors: Mainak Jas <mjas@mgh.harvard.edu>
#          Sam Neymotin <samnemo@gmail.com>

from copy import deepcopy

import numpy as np
from numpy.linalg import norm

from neuron import h, nrn

from .viz import plot_cell_morphology
from .externals.mne import _validate_type, _check_option

# Units for e: mV
# Units for gbar: S/cm^2


def _get_cos_theta(sections, sec_name_apical):
    """Get cos(theta) to compute dipole along the apical dendrite."""
    a = (np.array(sections[sec_name_apical].end_pts[1]) -
         np.array(sections[sec_name_apical].end_pts[0]))
    cos_thetas = dict()
    for sec_name, section in sections.items():
        b = np.array(section.end_pts[1]) - np.array(section.end_pts[0])
        cos_thetas[sec_name] = np.dot(a, b) / (norm(a) * norm(b))
    return cos_thetas


def _calculate_gaussian(x_val, height, lamtha):
    """Return height of gaussian at x_val.

    Parameters
    ----------
    x_val : float
        Value on x-axis to query height of gaussian curve.
    height : float
        Height of the gaussian curve at zero.
    lamtha : float
        Space constant.

    Returns
    -------
    x_height : float
        Height of gaussian at x_val.

    Notes
    -----
    Gaussian curve is centered at zero and has a fixed peak height
    such the _calculate_gaussian(0, lamtha) returns 1 for all lamtha.
    """
    x_height = height * np.exp(-(x_val**2) / (lamtha**2))

    return x_height


def _get_gaussian_connection(src_pos, target_pos, nc_dict,
                             inplane_distance=1.):
    """Calculate distance dependent connection properties.

    Parameters
    ----------
    src_pos : float
        Position of source cell.
    target_pos : float
        Position of target cell.
    nc_dict : dict
        Dictionary with keys: pos_src, A_weight, A_delay, lamtha
        Defines the connection parameters
    inplane_distance : float
        The in plane-distance (in um) between pyramidal cell somas in the
        square grid. Default: 1.0 um.

    Returns
    -------
    weight : float
        Weight of the synaptic connection.
    delay : float
        Delay of synaptic connection.

    Notes
    -----
    Distance in xy plane is used for gaussian decay.
    """
    x_dist = target_pos[0] - src_pos[0]
    y_dist = target_pos[1] - src_pos[1]
    cell_dist = np.sqrt(x_dist**2 + y_dist**2)
    scaled_lamtha = nc_dict['lamtha'] * inplane_distance

    weight = _calculate_gaussian(
        cell_dist, nc_dict['A_weight'], scaled_lamtha)
    delay = nc_dict['A_delay'] / _calculate_gaussian(
        cell_dist, 1, scaled_lamtha)
    return weight, delay


def node_to_str(node):
    return node[0] + "," + str(node[1])


class _ArtificialCell:
    """The ArtificialCell class for initializing a NEURON feed source.

    Parameters
    ----------
    event_times : list
        Spike times associated with a single feed source (i.e.,
        associated with a unique gid).
    threshold : float
        Membrane potential threshold that demarks a spike.
    gid : int or None (optional)
        Each cell in a network is uniquely identified by it's "global ID": GID.
        The GID is an integer from 0 to n_cells, or None if the cell is not
        yet attached to a network. Once the GID is set, it cannot be changed.

    Attributes
    ----------
    nrn_eventvec : instance of h.Vector()
        NEURON h.Vector() object of event times.
    nrn_vecstim : instance of h.VecStim()
        NEURON h.VecStim() object of spike sources created
        from nrn_eventvec.
    nrn_netcon : instance of h.NetCon()
        NEURON h.NetCon() object that creates the spike
        source-to-target references for nrn_vecstim.
    gid : int
        GID of the cell in a network (or None if not yet assigned)
    """
    def __init__(self, event_times, threshold, gid=None):
        # Convert event times into nrn vector
        self.nrn_eventvec = h.Vector()
        self.nrn_eventvec.from_python(event_times)

        # load eventvec into VecStim object
        self.nrn_vecstim = h.VecStim()
        self.nrn_vecstim.play(self.nrn_eventvec)

        # create the cell and artificial NetCon
        self.nrn_netcon = h.NetCon(self.nrn_vecstim, None)
        self.nrn_netcon.threshold = threshold

        self._gid = None
        if gid is not None:
            self.gid = gid  # use setter method to check input argument gid

    @property
    def gid(self):
        return self._gid

    @gid.setter
    def gid(self, gid):
        if not isinstance(gid, int):
            raise ValueError('gid must be an integer')
        if self._gid is None:
            self._gid = gid
        else:
            raise RuntimeError('Global ID for this cell already assigned!')


def _get_nseg(L):
    nseg = 1
    if L > 100.:  # 100 um
        nseg = int(L / 50.)
        # make dend.nseg odd for all sections
        if not nseg % 2:
            nseg += 1
    return nseg


class Section:
    """Section class.

    Parameters
    ----------
    L : float
        length of a section in microns.
    diam : float
        diameter of a section in microns.
    cm : float
        membrane capacitance in micro-Farads.
    Ra : float
        axial resistivity in ohm-cm
    end_pts : list of [x, y, z]
        The start and stop points of the section.

    Attributes
    ----------
    mechs : dict
        Mechanisms to insert in this section. The keys
        are the names of the mechanisms and values
        are the properties. For e.g., {'ca': {'gbar_ca': 60}}
    syns : list of str
        The synaptic mechanisms to add in this section
    end_pts : list of [x, y, z]
        The start and stop points of the section. Cannot be changed.
    L : float
        length of a section in microns.
    diam : float
        diameter of a section in microns.
    cm : float
        membrane capacitance in micro-Farads.
    Ra : float
        axial resistivity in ohm-cm.
    nseg : int
        Number of segments in the section
    """
    def __init__(self, L, diam, Ra, cm, end_pts=None):

        self._L = L
        self._diam = diam
        self._Ra = Ra
        self._cm = cm
        if end_pts is None:
            end_pts = list()
        self._end_pts = end_pts

        self.mechs = dict()
        self.syns = list()

        # For distance functionality
        self.nseg = _get_nseg(self.L)

    def __repr__(self):
        return f'L={self.L}, diam={self.diam}, cm={self.cm}, Ra={self.Ra}'

    def __eq__(self, other):
        if not isinstance(other, Section):
            return NotImplemented

        # Check equality for mechs
        for mech_name in self.mechs.keys():
            self_mech = self.mechs[mech_name]
            other_mech = other.mechs[mech_name]
            for attr in self_mech.keys():
                if self_mech[attr] != other_mech[attr]:
                    return False

        # Check end_pts
        for self_end_pt, other_end_pt in zip(self.end_pts, other.end_pts):
            if np.testing.assert_almost_equal(self_end_pt,
                                              other_end_pt, 5) is not None:
                return False

        all_attrs = dir(self)
        attrs_to_ignore = [x for x in all_attrs if x.startswith('_')]
        attrs_to_ignore.extend(['end_pts', 'mechs', 'to_dict'])
        attrs_to_check = [x for x in all_attrs if x not in attrs_to_ignore]

        # Check all other attributes
        for attr in attrs_to_check:
            if getattr(self, attr) != getattr(other, attr):
                return False

        return True

    def to_dict(self):
        """Converts an object of Section class to a dictionary.

        Returns
        -------
        dictionary form of an object of Section class.
        """
        section_data = dict()
        section_data['L'] = self.L
        section_data['diam'] = self.diam
        section_data['cm'] = self.cm
        section_data['Ra'] = self.Ra
        section_data['end_pts'] = self.end_pts
        section_data['nseg'] = self.nseg
        # Need to solve the partial function problem
        # in mechs
        section_data['mechs'] = self.mechs
        section_data['syns'] = self.syns
        return section_data

    @property
    def L(self):
        return self._L

    @property
    def diam(self):
        return self._diam

    @property
    def cm(self):
        return self._cm

    @property
    def Ra(self):
        return self._Ra

    @property
    def end_pts(self):
        return self._end_pts


[docs] class Cell: """Create a cell object. Parameters ---------- name : str The name of the cell. pos : tuple The (x, y, z) coordinates. sections : dict of Section Dictionary with keys as section name. synapses : dict of dict Keys are name of synaptic mechanism. Each synaptic mechanism has keys for parameters of the mechanism, e.g., 'e', 'tau1', 'tau2'. sections. sect_loc : dict of list Can have keys 'proximal' or 'distal' each containing names of section locations that are proximal or distal. gid : int or None (optional) Each cell in a network is uniquely identified by it's "global ID": GID. The GID is an integer from 0 to n_cells, or None if the cell is not yet attached to a network. Once the GID is set, it cannot be changed. cell_tree : dict of list Stores the tree representation of a cell. Root is the 0 end of 'soma'. Nodes are a tuple (sec_name, node_pos) where sec_name is the name of the section and node_pos is the 0 end or 1 end. The data structure is the adjacency list representation of a tree. The keys of the dict are the parent nodes. The value is the list of nodes (children nodes) connected to the parent node. Attributes ---------- pos : list of length 3 The position of the cell. sections : nested dict The section parameters. The key is the name of the section and the value is a dictionary parametrizing the morphology of the section and the mechanisms inserted. synapses : dict The synapses that the cell can use for connections. dipole_pp : list of h.Dipole() The Dipole objects (see dipole.mod). vsec : dict Recording of section specific voltage. Must be enabled by running simulate_dipole(net, record_vsec=True) or simulate_dipole(net, record_vsoma=True) isec : dict Contains recording of section specific currents indexed by synapse type (keys can be soma_gabaa, soma_gabab etc.). Must be enabled by running simulate_dipole(net, record_isec=True) or simulate_dipole(net, record_isoma=True) ca : dict Contains recording of section speicifc calcium concentration. Must be enabled by running simulate_dipole(net, record_ca=True). tonic_biases : list of h.IClamp The current clamps inserted at each section of the cell for tonic biasing inputs. gid : int GID of the cell in a network (or None if not yet assigned) sect_loc : dict of list Can have keys 'proximal' or 'distal' each containing names of section locations that are proximal or distal. cell_tree : dict of list Stores the tree representation of a cell. Root is the 0 end of 'soma'. Nodes are a tuple (sec_name, node_pos) where sec_name is the name of the section and node_pos is the 0 end or 1 end. The data structure is the adjacency list representation of a tree. The keys of the dict are the parent nodes. The value is the list of nodes (children nodes) connected to the parent node. Examples -------- >>> section_soma = Section( L=39, diam=20, cm=0.85, Ra=200., end_pts=[[0, 0, 0], [0, 39., 0]] ) """ def __init__(self, name, pos, sections, synapses, sect_loc, cell_tree, gid=None): self.name = name self.pos = pos for section in sections.values(): if not isinstance(section, Section): raise ValueError(f'Items in section must be instances' f' of Section. Got {type(section)}') self.sections = sections self.synapses = synapses self.sect_loc = sect_loc self._nrn_sections = dict() self._nrn_synapses = dict() self.dipole_pp = list() self.vsec = dict() self.isec = dict() self.ca = dict() # insert iclamp self.list_IClamp = list() self._gid = None self.tonic_biases = list() if gid is not None: self.gid = gid # use setter method to check input argument gid # Store the tree representation of the cell self.cell_tree = cell_tree self._update_end_pts() # New implementation self._compute_section_mechs() # Set mech values of all sections
[docs] def __repr__(self): class_name = self.__class__.__name__ return f'<{class_name} | gid={self._gid}>'
def __eq__(self, other): if not isinstance(other, Cell): return NotImplemented all_attrs = dir(self) attrs_to_ignore = [x for x in all_attrs if x.startswith('_')] attrs_to_ignore.extend(['build', 'copy', 'create_tonic_bias', 'define_shape', 'distance_section', 'gid', 'list_IClamp', 'modify_section', 'parconnect_from_src', 'plot_morphology', 'record', 'sections', 'setup_source_netcon', 'syn_create', 'to_dict']) attrs_to_check = [x for x in all_attrs if x not in attrs_to_ignore] # Check all other attributes for attr in attrs_to_check: if getattr(self, attr) != getattr(other, attr): return False if not (self.sections.keys() == other.sections.keys()): return False for key in self.sections.keys(): if self.sections[key] != other.sections[key]: return False return True
[docs] def to_dict(self): """Converts an object of Cell class to a dictionary. Returns ------- dictionary form of an object of Cell class. """ cell_data = dict() cell_data['name'] = self.name cell_data['pos'] = self.pos cell_data['sections'] = dict() for key in self.sections: cell_data['sections'][key] = self.sections[key].to_dict() cell_data['synapses'] = self.synapses # cell_data['cell_tree'] = self.cell_tree if self.cell_tree is None: cell_data['cell_tree'] = None else: cell_tree_dict = dict() for parent, children in self.cell_tree.items(): key = node_to_str(parent) value = list() for child in children: value.append(node_to_str(child)) cell_tree_dict[key] = value cell_data['cell_tree'] = cell_tree_dict cell_data['sect_loc'] = self.sect_loc cell_data['gid'] = self.gid cell_data['dipole_pp'] = self.dipole_pp cell_data['vsec'] = self.vsec cell_data['isec'] = self.isec cell_data['ca'] = self.ca cell_data['tonic_biases'] = self.tonic_biases return cell_data
@property def gid(self): return self._gid @gid.setter def gid(self, gid): if not isinstance(gid, int): raise ValueError('gid must be an integer') if self._gid is None: self._gid = gid else: raise RuntimeError('Global ID for this cell already assigned!')
[docs] def distance_section(self, target_sec_name, curr_node): """Find distance between the current node and the target section. Parameters ---------- target_sec_name : string Name of the target section curr_node : tuple Source node from where search begins. It is of the the form (sec_name, end_pt). Returns ------- distance : float Path distance between source node and mid of the target section. """ # Python version of the Neuron distance function # https://nrn.readthedocs.io/en/latest/python/modelspec/programmatic/topology/geometry.html#distance # noqa if self.cell_tree is None: raise TypeError("distance_section() " "cannot work with cell_tree as None.") if curr_node not in self.cell_tree: return np.nan # Children of the current section curr_sec_children = self.cell_tree[curr_node] # All sections have 0 and 1 ends end_pts = (0, 1) # Base condition # If target section is connected to current section # Return (target section length / 2) # As distances are measured till the centre of the target section for end_pt in end_pts: if (target_sec_name, end_pt) in curr_sec_children: return self.sections[target_sec_name].L / 2 dist = np.nan # Return nan # Recursion to find distance for node in self.cell_tree[curr_node]: if (node[0] == curr_node[0]): dist_temp = (self.distance_section(target_sec_name, node) + self.sections[node[0]].L) else: dist_temp = self.distance_section(target_sec_name, node) if np.isnan(dist) and np.isnan(dist_temp): dist = np.nan else: dist = np.nanmin([dist, dist_temp]) return dist
def _set_biophysics(self, sections): "Set the biophysics for the cell." # neuron syntax is used to set values for mechanisms # sec.gbar_mech = x sets value of gbar for mech to x for all segs # in a section. This method is significantly faster than using # a for loop to iterate over all segments to set mech values # If value depends on distance from the soma. Soma is set as # origin by passing cell.soma as a sec argument to h.distance() # Then iterate over segment nodes of dendritic sections # and set attribute depending on h.distance(seg.x), which returns # distance from the soma to this point on the CURRENTLY ACCESSED # SECTION!!! h.distance(sec=self._nrn_sections['soma']) for sec_name, section in sections.items(): sec = self._nrn_sections[sec_name] for mech_name, p_mech in section.mechs.items(): sec.insert(mech_name) for attr, val in p_mech.items(): if isinstance(val, list): seg_xs, seg_vals = val[0], val[1] for seg, seg_x, seg_val in zip(sec, seg_xs, seg_vals): setattr(seg, attr, seg_val) else: setattr(sec, attr, val) def _compute_section_mechs(self): sections = self.sections for sec_name, section in sections.items(): for mech_name, p_mech in section.mechs.items(): for attr, val in p_mech.items(): if hasattr(val, '__call__'): seg_xs, seg_vals = list(), list() section_distance = self.distance_section(sec_name, ('soma', 0)) seg_centers = (np.linspace(0, 1, section.nseg * 2 + 1) [1::2]) for seg_x in seg_centers: # sec_end_dist is distance between 0 end of soma to # the 0 or 1 end of section (whichever is closer) sec_end_dist = section_distance - (section.L / 2) seg_xs.append(seg_x) seg_vals.append(val(sec_end_dist + (seg_x * section.L))) p_mech[attr] = [seg_xs, seg_vals] return self.sections def _create_synapses(self, sections, synapses): """Create synapses.""" for sec_name in sections: for receptor in sections[sec_name].syns: syn_key = f'{sec_name}_{receptor}' seg = self._nrn_sections[sec_name](0.5) self._nrn_synapses[syn_key] = self.syn_create( seg, **synapses[receptor]) def _create_sections(self, sections, cell_tree): """Create soma and set geometry. Notes ----- By default neuron uses xy plane for height and xz plane for depth. This is opposite for model as a whole, but convention is followed in this function ease use of gui. """ if 'soma' not in self.sections: raise KeyError('soma must be defined for cell') for sec_name in sections: sec = h.Section(name=f'{self.name}_{sec_name}') self._nrn_sections[sec_name] = sec h.pt3dclear(sec=sec) h.pt3dconst(0, sec=sec) # be explicit, see documentation for pt in sections[sec_name].end_pts: h.pt3dadd(pt[0], pt[1], pt[2], 1, sec=sec) # with pt3dconst==0, these will alter the 3d points defined above! sec.L = sections[sec_name].L sec.diam = sections[sec_name].diam sec.Ra = sections[sec_name].Ra sec.cm = sections[sec_name].cm sec.nseg = sections[sec_name].nseg if cell_tree is None: cell_tree = dict() # Connects sections of THIS cell together. for parent_node in cell_tree: for child_node in cell_tree[parent_node]: parent_sec = self._nrn_sections[parent_node[0]] child_sec = self._nrn_sections[child_node[0]] if parent_sec == child_sec: continue parent_loc = parent_node[1] child_loc = child_node[1] child_sec.connect(parent_sec, parent_loc, child_loc) # be explicit about letting sec.L dominate over the 3d points used by # h.pt3dadd(); see # https://nrn.readthedocs.io/en/latest/python/modelspec/programmatic/topology/geometry.html?highlight=pt3dadd#pt3dadd # noqa h.define_shape()
[docs] def build(self, sec_name_apical=None): """Build cell in Neuron and insert dipole if applicable. Parameters ---------- sec_name_apical : str | None If not None, a dipole will be inserted in this cell in alignment with this section. The section should belong to the apical dendrite of a pyramidal neuron. """ self._create_sections(self.sections, self.cell_tree) self._create_synapses(self.sections, self.synapses) self._set_biophysics(self.sections) if sec_name_apical in self._nrn_sections: self._insert_dipole(sec_name_apical) elif sec_name_apical is not None: raise ValueError(f'sec_name_apical must be an existing ' f'section of the current cell or None. ' f'Got {sec_name_apical}.')
[docs] def copy(self): """Return copy of instance.""" return deepcopy(self)
# two things need to happen here for h: # 1. dipole needs to be inserted into each section # 2. a list needs to be created with a Dipole (Point Process) in each # section at position 1 # In Cell() and not Pyr() for future possibilities def _insert_dipole(self, sec_name_apical): """Insert dipole into each section of this cell. Parameters ---------- sec_name_apical : str The name of the section along which dipole moment is calculated. """ self.dpl_vec = h.Vector(1) self.dpl_ref = self.dpl_vec._ref_x[0] cos_thetas = _get_cos_theta(self.sections, 'apical_trunk') # setting pointers and ztan values for sect_name in self.sections: sect = self._nrn_sections[sect_name] sect.insert('dipole') dpp = h.Dipole(1, sec=sect) # defined in dipole_pp.mod self.dipole_pp.append(dpp) dpp.ri = h.ri(1, sec=sect) # assign internal resistance # sets pointers in dipole mod file to the correct locations dpp._ref_pv = sect(0.99)._ref_v dpp._ref_Qtotal = self.dpl_ref # gives INTERNAL segments of the section, non-endpoints # creating this because need multiple values simultaneously pos_all = np.array([seg.x for seg in sect.allseg()]) seg_lens = np.diff(pos_all) * sect.L seg_lens_z = seg_lens * cos_thetas[sect_name] # alternative procedure below with y_long(itudinal) # y_long = (h.y3d(1, sec=sect) - h.y3d(0, sec=sect)) * pos # y_diff = np.diff(y_long) # doing range to index multiple values of the same # np.array simultaneously for idx, pos in enumerate(pos_all[1:-1]): # assign the ri value to the dipole # ri not defined at 0 and L sect(pos).dipole.ri = h.ri(pos, sec=sect) # range variable 'dipole' # set pointers to previous segment's voltage, with # boundary condition sect(pos).dipole._ref_pv = sect(pos_all[idx])._ref_v # set aggregate pointers sect(pos).dipole._ref_Qsum = dpp._ref_Qsum sect(pos).dipole._ref_Qtotal = self.dpl_ref # add ztan values sect(pos).dipole.ztan = seg_lens_z[idx] # set the pp dipole's ztan value to the last value from seg_lens_z dpp.ztan = seg_lens_z[-1] self.dipole = h.Vector().record(self.dpl_ref)
[docs] def create_tonic_bias(self, amplitude, t0, tstop, loc=0.5): """Create tonic bias at the soma. Parameters ---------- amplitude : float The amplitude of the input. t0 : float The start time of tonic input (in ms). tstop : float The end time of tonic input (in ms). loc : float (0 to 1) The location of the input in the soma section. """ stim = h.IClamp(self._nrn_sections['soma'](loc)) stim.delay = t0 stim.dur = tstop - t0 stim.amp = amplitude self.tonic_biases.append(stim)
[docs] def record(self, record_vsec=False, record_isec=False, record_ca=False): """ Record current and voltage from all sections Parameters ---------- record_vsec : 'all' | 'soma' | False Option to record voltages from all sections ('all'), or just the soma ('soma'). Default: False. record_isec : 'all' | 'soma' | False Option to record voltages from all sections ('all'), or just the soma ('soma'). Default: False. record_ca : 'all' | 'soma' | False Option to record calcium concentration from all sections ('all'), or just the soma ('soma'). Default: False. """ section_names = list(self.sections.keys()) # Logic checks if just recording soma, sections, or both if record_vsec == 'soma': self.vsec = dict.fromkeys(['soma']) elif record_vsec == 'all': self.vsec = dict.fromkeys(section_names) if record_vsec: for sec_name in self.vsec: self.vsec[sec_name] = h.Vector() self.vsec[sec_name].record( self._nrn_sections[sec_name](0.5)._ref_v) if record_isec == 'soma': self.isec = dict.fromkeys(['soma']) elif record_isec == 'all': self.isec = dict.fromkeys(section_names) if record_isec: for sec_name in self.isec: list_syn = [key for key in self._nrn_synapses.keys() if key.startswith(f'{sec_name}_')] self.isec[sec_name] = dict.fromkeys(list_syn) for syn_name in self.isec[sec_name]: self.isec[sec_name][syn_name] = h.Vector() self.isec[sec_name][syn_name].record( self._nrn_synapses[syn_name]._ref_i) # calcium concentration if record_ca == 'soma': self.ca = dict.fromkeys(['soma']) elif record_ca == 'all': self.ca = dict.fromkeys(section_names) if record_ca: for sec_name in self.ca: if hasattr(self._nrn_sections[sec_name](0.5), '_ref_cai'): self.ca[sec_name] = h.Vector() self.ca[sec_name].record( self._nrn_sections[sec_name](0.5)._ref_cai)
[docs] def syn_create(self, secloc, e, tau1, tau2): """Create an h.Exp2Syn synapse. Parameters ---------- secloc : instance of nrn.Segment The section location. E.g., soma(0.5). e: float Reverse potential (in mV) tau1: float Rise time (in ms) tau2: float Decay time (in ms) Returns ------- syn : instance of h.Exp2Syn A two state kinetic scheme synapse. """ if not isinstance(secloc, nrn.Segment): raise TypeError(f'secloc must be instance of' f'nrn.Segment. Got {type(secloc)}') syn = h.Exp2Syn(secloc) syn.e = e syn.tau1 = tau1 syn.tau2 = tau2 return syn
[docs] def setup_source_netcon(self, threshold): """Created for _PC.cell and specifies SOURCES of spikes. Parameters ---------- threshold : float The voltage threshold for action potential. """ nc = h.NetCon(self._nrn_sections['soma'](0.5)._ref_v, None, sec=self._nrn_sections['soma']) nc.threshold = threshold return nc
[docs] def parconnect_from_src(self, gid_presyn, nc_dict, postsyn, inplane_distance): """Parallel receptor-centric connect FROM presyn TO this cell, based on GID. Parameters ---------- gid_presyn : int The cell ID of the presynaptic neuron nc_dict : dict Dictionary with keys: pos_src, A_weight, A_delay, lamtha Defines the connection parameters postsyn : instance of h.Exp2Syn The postsynaptic cell object. inplane_distance : float The in plane-distance (in um) between pyramidal cell somas in the square grid. Returns ------- nc : instance of h.NetCon A network connection object. """ from .network_builder import _PC nc = _PC.gid_connect(gid_presyn, postsyn) # set props here. nc.threshold = nc_dict['threshold'] nc.weight[0], nc.delay = _get_gaussian_connection( nc_dict['pos_src'], self.pos, nc_dict, inplane_distance=inplane_distance) return nc
[docs] def plot_morphology(self, ax=None, color=None, pos=(0, 0, 0), xlim=(-250, 150), ylim=(-100, 100), zlim=(-100, 1200), show=True): """Plot the cell morphology. Parameters ---------- ax : instance of Axes3D Matplotlib 3D axis color : str | dict | None Color of cell. If str, entire cell plotted with color indicated by str. If dict, colors of individual sections can be specified. Must have a key for every section in cell as defined in the `Cell.sections` attribute. | Ex: ``{'apical_trunk': 'r', 'soma': 'b', ...}`` pos : tuple of int or float | None Position of cell soma. Must be a tuple of 3 elements for the (x, y, z) position of the soma in 3D space. Default: (0, 0, 0) xlim : tuple of int | tuple of float x limits of plot window. Default (-250, 150) ylim : tuple of int | tuple of float y limits of plot window. Default (-100, 100) zlim : tuple of int | tuple of float z limits of plot window. Default (-100, 1200) show : bool If True, show the plot Returns ------- axes : instance of Axes3D The matplotlib 3D axis handle. """ return plot_cell_morphology(self, ax=ax, color=color, pos=pos, xlim=xlim, ylim=ylim, zlim=zlim, show=show)
def _update_section_end_pts_L(self, node, dpt): if self.cell_tree is None: return x = self.sections[node[0]].end_pts[node[1]][0] y = self.sections[node[0]].end_pts[node[1]][1] z = self.sections[node[0]].end_pts[node[1]][2] self.sections[node[0]].end_pts[node[1]][0] = x + dpt[0] self.sections[node[0]].end_pts[node[1]][1] = y + dpt[1] self.sections[node[0]].end_pts[node[1]][2] = z + dpt[2] # If current node is a leaf node if node not in self.cell_tree: return # If current node is an internal node for child_node in self.cell_tree[node]: self._update_section_end_pts_L(child_node, dpt)
[docs] def define_shape(self, node): """Redefines end_pts according to section lengths. Detects change in section lengths of the sections in the subtree of the input node. Parameters ---------- node : tuple of size 2 The first element is the section name The second element is the node end used (0 or 1) Note ---- Using sec_name as 'soma' and node end as 0 checks for changes in any section length of the cell as (soma, 0) is the root node of the cell. """ # Python version of Neuron define_shape function # https://nrn.readthedocs.io/en/latest/python/modelspec/programmatic/topology/geometry.html?highlight=pt3dadd#pt3dadd # noqa # cell tree is None therefore cannot define shape if self.cell_tree is None: return # Find the end pts of the section node_opp_end = 1 if node[1] == 1: node_opp_end = 0 pts = self.sections[node[0]].end_pts x0, y0, z0 = pts[node[1]][0], pts[node[1]][1], pts[node[1]][2] x1, y1, z1 = (pts[node_opp_end][0], pts[node_opp_end][1], pts[node_opp_end][2]) # Find the factor by which length is changed end_1 = np.array((x0, y0, z0)) end_2 = np.array((x1, y1, z1)) old_len = np.linalg.norm(end_1 - end_2) new_len = self.sections[node[0]].L fac = new_len / old_len x_new = x0 + (x1 - x0) * fac y_new = y0 + (y1 - y0) * fac z_new = z0 + (z1 - z0) * fac # Find the change in coordinates dx = x_new - x1 dy = y_new - y1 dz = z_new - z1 dpt = [dx, dy, dz] # Update all coordinates in the subtree self._update_section_end_pts_L((node[0], node_opp_end), dpt) # Check for change in section lengths in the subtree if node in self.cell_tree: for child_node in self.cell_tree[node]: self.define_shape(child_node)
def _update_end_pts(self): """Update all end pts according to the length of the sections. Can be used whenever length of any section is updated Returns ------- Updated end pts for the cell """ if 'soma' not in self.sections: raise KeyError('soma must be defined for cell') # cell tree is None therefore no end_pts to update if self.cell_tree is None: return # shift cell to self.pos and reorient apical dendrite # along z direction of self.pos dx = self.pos[0] - self.sections['soma'].end_pts[0][0] dy = self.pos[1] - self.sections['soma'].end_pts[0][1] dz = self.pos[2] - self.sections['soma'].end_pts[0][2] for sec_name in self.sections: end_pts = self.sections[sec_name].end_pts updated_end_pts = list() for pt in end_pts: updated_end_pts.append( [ pt[0] + dx, pt[1] + dy, pt[2] + dz ] ) self.sections[sec_name]._end_pts = updated_end_pts # Check and update all end pts starting from root according to length # of sections. self.define_shape(('soma', 0))
[docs] def modify_section(self, sec_name, L=None, diam=None, cm=None, Ra=None): """Change attributes of section specified by `sec_name` Parameters ---------- sec_name : str Name of section to be modified. Must be a key of Cell.sections L : float | int | None length of a section in microns. Default None. diam : float | int | None diameter of a section in microns. cm : float | int | None membrane capacitance in micro-Farads. Ra : float | int | None axial resistivity in ohm-cm. Notes ----- Leaving default of None produces no change. """ valid_sec_names = list(self.sections.keys()) _check_option('sec_name', sec_name, valid_sec_names) if L is not None: _validate_type(L, (float, int), 'L') self.sections[sec_name]._L = L if diam is not None: _validate_type(diam, (float, int), 'diam') self.sections[sec_name]._diam = diam if cm is not None: _validate_type(cm, (float, int), 'cm') self.sections[sec_name]._cm = cm if Ra is not None: _validate_type(Ra, (float, int), 'Ra') self.sections[sec_name]._Ra = Ra self._update_end_pts()