[ENH] Added read/write method for network object

hnn_core/__init__.py

@@ -6,5 +6,6 @@
 from .cell_response import CellResponse, read_spikes
 from .cells_default import pyramidal, basket
 from .parallel_backends import MPIBackend, JoblibBackend
+from .io import read_network
 
 __version__ = '0.4.dev0'

hnn_core/cell.py

@@ -95,6 +95,10 @@ def _get_gaussian_connection(src_pos, target_pos, nc_dict,
     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.
 
@@ -220,6 +224,52 @@ def __init__(self, L, diam, Ra, cm, end_pts=None):
     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 self_end_pt != other_end_pt:
+                if np.testing.assert_almost_equal(self_end_pt,
+                                                  other_end_pt, 5):
+                    print(self_end_pt)
+                    print(other_end_pt)
+                    return False
+
+        # Check all other attributes
+        if (self.L != other.L or
+           self.diam != other.diam or
+           self.Ra != other.Ra or
+           self.cm != other.cm or
+           self.nseg != other.nseg or
+           self.syns != other.syns):
+            return False
+
+        return True
+
+    def to_dict(self):
+        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
@@ -355,6 +405,57 @@ 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
+        if not (self.name == other.name and
+                self.pos == other.pos and
+                self.synapses == other.synapses and
+                self.cell_tree == other.cell_tree and
+                self.sect_loc == other.sect_loc and
+                self.dipole_pp == other.dipole_pp and
+                self.vsec == other.vsec and
+                self.isec == other.isec and
+                self.tonic_biases == other.tonic_biases):
+            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
+
+    def to_dict(self):
+        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['tonic_biases'] = self.tonic_biases
+        return cell_data
+
     @property
     def gid(self):
         return self._gid
@@ -444,8 +545,6 @@ def _set_biophysics(self, sections):
                     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):
-                            # Checking equality till 5 decimal places
-                            np.testing.assert_almost_equal(seg.x, seg_x, 5)
                             setattr(seg, attr, seg_val)
                     else:
                         setattr(sec, attr, val)

hnn_core/docs.py

@@ -0,0 +1,255 @@
+"""The documentation functions."""
+
+docdict = dict()
+# Define docdicts
+
+docdict[
+    "net"
+] = """
+net : Instance of Network object
+    The Network object
+"""
+
+docdict[
+    "fname"
+] = """
+fname : str | Path object
+    Full path to the output file (.hdf5)
+"""
+
+docdict[
+    "overwrite"
+] = """
+overwrite : Boolean
+    True : Overwrite existing file
+    False : Throw error if file already exists
+"""
+
+docdict[
+    "save_unsimulated"
+] = """
+save_unsimulated : Boolean
+    True : Do not save the Network simulation output
+    False : Save complete Network as provided in input
+"""
+
+docdict[
+    "read_raw"
+] = """
+read_raw : Boolean
+    True : Read unsimulated network
+    False : Read simulated network
+"""
+
+docdict[
+    "section_description"
+] = """
+section description
+-------------------
+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.
+mechs : dict
+    Mechanisms to insert in this section. The keys
+    are the names of the mechanisms and values
+    are the properties.
+syns : list of str
+    The synaptic mechanisms to add in this section.
+"""
+
+docdict[
+    "cell_description"
+] = f"""
+cell_name : str
+    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'.
+topology : list of list
+    The topology of cell sections. Each element is a list of
+    4 items in the format
+    [parent_sec, parent_loc, child_sec, child_loc] where
+    parent_sec and parent_loc are float between 0 and 1
+    specifying the location in the section to connect and
+    parent_sec and child_sec are names of the connecting
+    sections.
+sect_loc : dict of list
+    Can have keys 'proximal' or 'distal' each containing
+gid : int
+    GID of the cell in a network (or None if not yet assigned)
+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)
+tonic_biases : list of h.IClamp
+    The current clamps inserted at each section of the cell
+    for tonic biasing inputs.
+
+{docdict['section_description']}
+"""
+
+docdict[
+    "gid_range_description"
+] = """
+start : int
+    Start of the gid_range
+stop : int
+    End of the gid_range
+"""
+
+docdict[
+    "external_drive_description"
+] = """
+name : str
+    Unique name for the drive
+dynamics : dict
+    Parameters describing how the temporal dynamics of spike trains in the
+    drive. The keys are specific to the type of drive ('evoked', 'bursty',
+    etc.).
+location : str
+    Target location of synapses.
+cell_specific : bool
+    Whether each artifical drive cell has 1-to-1 (True, default) or
+    all-to-all (False) connection parameters.
+weights_ampa : dict or None
+    Synaptic weights (in uS) of AMPA receptors on each targeted cell
+    type (dict keys).
+weights_nmda : dict or None
+    Synaptic weights (in uS) of NMDA receptors on each targeted cell
+    type (dict keys).
+probability : dict or float
+    Probability of connection between any src-target pair.
+    Use dict to create probability->cell mapping. If float, applies to
+    all target cell types
+synaptic_delays : dict or float
+    Synaptic delay (in ms) at the column origin, dispersed laterally as
+    a function of the space_constant. If float, applies to all target
+    cell types.
+event_seed : int
+    Optional initial seed for random number generator.
+conn_seed : int
+    Optional initial seed for random number generator
+n_drive_cells : int | 'n_cells'
+    The number of drive cells that each contribute an independently
+    sampled synaptic spike to the network according to the Gaussian
+    time distribution (mu, sigma).
+events : list
+    Contains the spike times of exogeneous inputs.
+"""
+
+docdict[
+    "external_bias_description"
+] = """
+cell_type : str
+    The cell type whose cells will get the tonic input.
+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).
+"""
+
+docdict[
+    "connection_description"
+] = """
+target_type : str
+    Cell type of target gids.
+target_gids : list of int
+    Identifer for targets of source cells
+num_targets : int
+    Number of unique target gids.
+src_type : str
+    Cell type of source gids.
+src_gids : list of int
+    Identifier for source cells.
+num_srcs : int
+    Number of unique source gids.
+gid_pairs : dict
+    dict indexed by src gids
+loc : str
+    Target location of synapses.
+receptor : str
+    Synaptic receptor of connection.
+nc_dict : dict
+    Contains information about delay, weight, lamtha etc.
+allow_autapses : bool
+    If True, allow connecting neuron to itself.
+probability : float
+    Probability of connection between any src-target pair.
+"""
+
+docdict[
+    "extracellular_array_description"
+] = """
+positions : tuple | list of tuple
+    The (x, y, z) coordinates (in um) of the extracellular electrodes.
+conductivity : float
+    Extracellular conductivity, in S/m
+method : str
+    Approximation to use.
+min_distance : float
+    To avoid numerical errors in calculating potentials, apply a minimum
+    distance limit between the electrode contacts and the active neuronal
+    membrane elements that act as sources of current.
+times : array-like, shape (n_times,) | None
+    Optionally, provide precomputed voltage sampling times for electrodes
+    at `positions`.
+voltages : array-like, shape (n_trials, n_electrodes, n_times) | None
+    Optionally, provide precomputed voltages for electrodes at
+    ``positions``.
+"""
+
+docdict[
+    "network_file_content_description"
+] = """
+object_type : str
+    Type of object (Network) saved
+N_pyr_x : int
+N_pyr_y : int
+threshold : float
+    Firing threshold of all cells.
+celsius : float
+cell_types : dict of Cell Object
+    key : name of cell type
+    value : Cell object
+gid_ranges : dict of dict
+    key : cell name or drive name
+    value : dict
+pos_dict : dict
+    key : cell type name
+    value : All co-ordintes of the cell types
+cell_response : Instance of Cell Response Object
+    The Cell Response object
+external_drives : dict of dict
+    key : external drive name
+    value : dict
+external_biases : dict of dict
+    key : external bias name
+    value : dict
+connectivity : list of dict
+rec_arrays : dict of Extracellular Arrays
+    key : extracellular array name
+    value : Instance of Extracellular Array object
+delay : float
+    Synaptic delay in ms.
+"""