[MRG+1] unify cell connectivity and drive connectivity

doc/whats_new.rst

@@ -40,6 +40,8 @@ Changelog
 
 - Add :func:`~hnn_core.Network.pick_connection` to query the indices of specific connections in :attr:`~hnn_core.Network.connectivity`, by `Nick Tolley`_ in `#367 <https://github.com/jonescompneurolab/hnn-core/pull/367>`_
 
+- Unify the codepath for instantiating drive and local network connectivity, by `Ryan Thorpe`_, `Mainak Jas`_, and `Nick Tolley`_ in `#369 <https://github.com/jonescompneurolab/hnn-core/pull/369>`_
+
 Bug
 ~~~
 
@@ -81,6 +83,8 @@ API
 
 - `~hnn_core.CellResponse.reset` method is not supported any more, by `Mainak Jas`_ in `#397 <https://github.com/jonescompneurolab/hnn-core/pull/397>`_
 
+- Target cell types and their connections are created for each drive according to the synaptic weight and delay dictionaries assigned in `Network.add_xxx_drive()`, by `Ryan Thorpe`_ in `#369 <https://github.com/jonescompneurolab/hnn-core/pull/369>`_
+
 .. _0.1:
 
 0.1

hnn_core/drives.py

@@ -10,14 +10,51 @@
                      _extract_drive_specs_from_hnn_params)
 
 
-def _get_target_populations(weights_ampa, weights_nmda):
+def _get_target_properties(weights_ampa, weights_nmda, synaptic_delays,
+                           location):
+    """Retrieve drive properties associated with each target cell type
+
+    Note that target cell types of a drive are inferred from the synaptic
+    weight and delay parameters keys defined by the user.
+    """
+
     # allow passing weights as None, but make iterable here
     if weights_ampa is None:
         weights_ampa = dict()
     if weights_nmda is None:
         weights_nmda = dict()
-    target_populations = (set(weights_ampa.keys()) | set(weights_nmda.keys()))
-    return target_populations, weights_ampa, weights_nmda
+
+    weights_by_type = {cell_type: dict() for cell_type in
+                       (set(weights_ampa.keys()) | set(weights_ampa.keys()))}
+    for cell_type in weights_ampa:
+        weights_by_type[cell_type].update({'ampa': weights_ampa[cell_type]})
+    for cell_type in weights_nmda:
+        weights_by_type[cell_type].update({'nmda': weights_nmda[cell_type]})
+
+    target_populations = set(weights_by_type)
+    if not target_populations:
+        raise ValueError('No target cell types have been given a synaptic '
+                         'weight for this drive.')
+    # Distal drives should not target L5 basket cells according to the
+    # canonical Jones model
+    if location == 'distal' and 'L5_basket' in target_populations:
+        raise ValueError('When adding a distal drive, synaptic weight cannot '
+                         'be defined for the L5_basket cell type as this '
+                         'connection does not exist.')
+
+    if isinstance(synaptic_delays, float):
+        delays_by_type = {cell_type: synaptic_delays for cell_type in
+                          target_populations}
+    else:
+        delays_by_type = synaptic_delays.copy()
+
+    if set(delays_by_type.keys()) != target_populations:
+        raise ValueError('synaptic_delays is either a common float or needs '
+                         'to be specified as a dict for each of the cell '
+                         'types defined in weights_ampa and weights_nmda '
+                         f'({target_populations})')
+
+    return target_populations, weights_by_type, delays_by_type
 
 
 def _check_drive_parameter_values(drive_type, **kwargs):

hnn_core/network_builder.py

@@ -17,6 +17,7 @@
 from .cell import _ArtificialCell
 from .params import _long_name, _short_name
 from .extracellular import _ExtracellularArrayBuilder
+from .network import pick_connection
 
 # a few globals
 _PC = None
@@ -363,23 +364,27 @@ def _gid_assign(self, rank=None, n_hosts=None):
 
         self.net._update_cells()  # updates net.n_cells
 
-        # round robin assignment of gids
+        # round robin assignment of cell gids
         for gid in range(self._rank, self.net.n_cells, n_hosts):
-            # set the cell gid
             self._gid_list.append(gid)
 
-        # loop over all drives, then all cell types, then all artificial cells
-        # only assign a "source" artificial cell to this rank if its target
-        # exists in _gid_list. "Global" drives get placed on different ranks
         for drive in self.net.external_drives.values():
             if drive['cell_specific']:
-                for conn in drive['conn'].values():  # all cell types
-                    for src_gid, target_gid in zip(conn['src_gids'],
-                                                   conn['target_gids']):
+                # only assign drive gids that have a target cell gid already
+                # assigned to this rank
+                for src_gid in self.net.gid_ranges[drive['name']]:
+                    conn_idxs = pick_connection(self.net, src_gids=src_gid)
+                    target_gids = list()
+                    for conn_idx in conn_idxs:
+                        target_gids += (self.net.connectivity[conn_idx]
+                                        ['gid_pairs'][src_gid])
+
+                    for target_gid in set(target_gids):
                         if (target_gid in self._gid_list and
                                 src_gid not in self._gid_list):
                             self._gid_list.append(src_gid)
             else:
+                # round robin assignment of drive gids
                 src_gids = list(self.net.gid_ranges[drive['name']])
                 for gid_idx in range(self._rank, len(src_gids), n_hosts):
                     self._gid_list.append(src_gids[gid_idx])

hnn_core/params.py

@@ -177,15 +177,15 @@ def _extract_drive_specs_from_hnn_params(params, cellname_list):
             if cname_ampa in par:
                 ampa_weight = par[cname_ampa][0]
                 ampa_delay = par[cname_ampa][1]
-                if ampa_weight > 0.:
+                if ampa_weight >= 0.:
                     drive['weights_ampa'][cellname] = ampa_weight
 
                 # NB synaptic delay same for NMDA, read only for AMPA
                 drive['synaptic_delays'][cellname] = ampa_delay
 
             if cname_nmda in par:
                 nmda_weight = par[cname_nmda][0]
-                if nmda_weight > 0.:
+                if nmda_weight >= 0.:
                     drive['weights_nmda'][cellname] = nmda_weight
 
         drive_specs[feed_name] = drive
@@ -228,9 +228,9 @@ def _extract_drive_specs_from_hnn_params(params, cellname_list):
                     ampa_weight = par[cellname][0]
                     nmda_weight = par[cellname][1]
                     synaptic_delays = par[cellname][2]
-                    if ampa_weight > 0.:
+                    if ampa_weight >= 0.:
                         drive['weights_ampa'][cellname] = ampa_weight
-                    if nmda_weight > 0.:
+                    if nmda_weight >= 0.:
                         drive['weights_nmda'][cellname] = nmda_weight
                     drive['synaptic_delays'][cellname] = synaptic_delays
 
@@ -249,7 +249,7 @@ def _extract_drive_specs_from_hnn_params(params, cellname_list):
                 if cellname in par:
                     ampa_weight = par[cellname][0]
                     synaptic_delays = par[cellname][3]
-                    if ampa_weight > 0.:
+                    if ampa_weight >= 0.:
                         drive['weights_ampa'][cellname] = ampa_weight
                     drive['synaptic_delays'][cellname] = synaptic_delays
 
@@ -272,9 +272,9 @@ def _extract_drive_specs_from_hnn_params(params, cellname_list):
                     ampa_weight = par[cellname][0]
                     nmda_weight = par[cellname][1]
                     synaptic_delays = par[cellname][2]
-                    if ampa_weight > 0.:
+                    if ampa_weight >= 0.:
                         drive['weights_ampa'][cellname] = ampa_weight
-                    if nmda_weight > 0.:
+                    if nmda_weight >= 0.:
                         drive['weights_nmda'][cellname] = nmda_weight
                     drive['synaptic_delays'][cellname] = synaptic_delays
 

hnn_core/tests/test_drives.py

@@ -11,6 +11,7 @@
 from hnn_core.drives import (drive_event_times, _get_prng, _create_extpois,
                              _create_bursty_input)
 from hnn_core.params import create_pext
+from hnn_core.network import pick_connection
 
 
 def test_external_drive_times():
@@ -115,10 +116,8 @@ def test_add_drives():
     net = Network(params, legacy_mode=False)
 
     # Ensure weights and delays are updated
-    weights_ampa = {'L2_basket': 1.0, 'L2_pyramidal': 3.0,
-                    'L5_basket': 2.0, 'L5_pyramidal': 4.0}
-    syn_delays = {'L2_basket': 1.0, 'L2_pyramidal': 2.0,
-                  'L5_basket': 3.0, 'L5_pyramidal': 4.0}
+    weights_ampa = {'L2_basket': 1.0, 'L2_pyramidal': 3.0, 'L5_pyramidal': 4.0}
+    syn_delays = {'L2_basket': 1.0, 'L2_pyramidal': 2.0, 'L5_pyramidal': 4.0}
 
     n_drive_cells = 10
     cell_specific = False  # default for bursty drive
@@ -129,9 +128,12 @@ def test_add_drives():
 
     assert net.external_drives['bursty']['n_drive_cells'] == n_drive_cells
     assert net.external_drives['bursty']['cell_specific'] == cell_specific
-    for type_name, drive in net.external_drives['bursty']['conn'].items():
-        assert drive['ampa']['A_weight'] == weights_ampa[type_name]
-        assert drive['ampa']['A_delay'] == syn_delays[type_name]
+    conn_idxs = pick_connection(net, src_gids='bursty')
+    for conn_idx in conn_idxs:
+        drive_conn = net.connectivity[conn_idx]
+        target_type = drive_conn['target_type']
+        assert drive_conn['nc_dict']['A_weight'] == weights_ampa[target_type]
+        assert drive_conn['nc_dict']['A_delay'] == syn_delays[target_type]
 
     n_drive_cells = 'n_cells'  # default for evoked drive
     cell_specific = True
@@ -140,13 +142,16 @@ def test_add_drives():
         weights_ampa=weights_ampa, location='distal',
         synaptic_delays=syn_delays, cell_specific=True)
 
-    n_dist_targets = 270  # 235 with non-legacy mode
+    n_dist_targets = 235  # 270 with legacy mode
     assert (net.external_drives['evoked_dist']
                                ['n_drive_cells'] == n_dist_targets)
     assert net.external_drives['evoked_dist']['cell_specific'] == cell_specific
-    for type_name, drive in net.external_drives['evoked_dist']['conn'].items():
-        assert drive['ampa']['A_weight'] == weights_ampa[type_name]
-        assert drive['ampa']['A_delay'] == syn_delays[type_name]
+    conn_idxs = pick_connection(net, src_gids='evoked_dist')
+    for conn_idx in conn_idxs:
+        drive_conn = net.connectivity[conn_idx]
+        target_type = drive_conn['target_type']
+        assert drive_conn['nc_dict']['A_weight'] == weights_ampa[target_type]
+        assert drive_conn['nc_dict']['A_delay'] == syn_delays[target_type]
 
     n_drive_cells = 'n_cells'  # default for poisson drive
     cell_specific = True
@@ -155,13 +160,16 @@ def test_add_drives():
         location='distal', synaptic_delays=syn_delays,
         cell_specific=cell_specific)
 
-    n_dist_targets = 270  # 235 with non-legacy mode
+    n_dist_targets = 235  # 270 with non-legacy mode
     assert (net.external_drives['poisson']
                                ['n_drive_cells'] == n_dist_targets)
     assert net.external_drives['poisson']['cell_specific'] == cell_specific
-    for type_name, drive in net.external_drives['poisson']['conn'].items():
-        assert drive['ampa']['A_weight'] == weights_ampa[type_name]
-        assert drive['ampa']['A_delay'] == syn_delays[type_name]
+    conn_idxs = pick_connection(net, src_gids='poisson')
+    for conn_idx in conn_idxs:
+        drive_conn = net.connectivity[conn_idx]
+        target_type = drive_conn['target_type']
+        assert drive_conn['nc_dict']['A_weight'] == weights_ampa[target_type]
+        assert drive_conn['nc_dict']['A_delay'] == syn_delays[target_type]
 
     # evoked
     with pytest.raises(ValueError,
@@ -182,6 +190,17 @@ def test_add_drives():
                        match='Drive evoked_dist already defined'):
         net.add_evoked_drive('evoked_dist', mu=10, sigma=1, numspikes=1,
                              location='distal')
+    with pytest.raises(ValueError,
+                       match='No target cell types have been given a synaptic '
+                       'weight'):
+        net.add_evoked_drive('evdist1', mu=10, sigma=1, numspikes=1,
+                             location='distal')
+    with pytest.raises(ValueError,
+                       match='When adding a distal drive, synaptic weight '
+                       'cannot be defined for the L5_basket cell type'):
+        net.add_evoked_drive('evdist1', mu=10, sigma=1, numspikes=1,
+                             location='distal', weights_ampa={'L5_basket': 1.},
+                             synaptic_delays={'L5_basket': .1})
     with pytest.raises(ValueError,
                        match='If cell_specific is True, n_drive_cells'):
         net.add_evoked_drive('evdist1', mu=10, sigma=1, numspikes=1,
@@ -217,18 +236,24 @@ def test_add_drives():
     with pytest.raises(ValueError,
                        match='Rate constant must be positive'):
         net.add_poisson_drive('poisson1', location='distal',
-                              rate_constant=0.)
+                              rate_constant=0.,
+                              weights_ampa=weights_ampa,
+                              synaptic_delays=syn_delays)
 
     with pytest.raises(ValueError,
                        match='Rate constants not provided for all target'):
         net.add_poisson_drive('poisson1', location='distal',
                               rate_constant={'L2_pyramidal': 10.},
-                              weights_ampa={'L5_pyramidal': .01})
+                              weights_ampa=weights_ampa,
+                              synaptic_delays=syn_delays)
     with pytest.raises(ValueError,
                        match='Rate constant provided for unknown target cell'):
         net.add_poisson_drive('poisson1', location='distal',
                               rate_constant={'L2_pyramidal': 10.,
-                                             'bogus_celltype': 20.})
+                                             'bogus_celltype': 20.},
+                              weights_ampa={'L2_pyramidal': .01,
+                                            'bogus_celltype': .01},
+                              synaptic_delays=0.1)
 
     with pytest.raises(ValueError,
                        match='Drives specific to cell types are only '
@@ -267,19 +292,24 @@ def test_add_drives():
     with pytest.raises(ValueError,
                        match='Drive evoked_dist already defined'):
         net.add_poisson_drive('evoked_dist', location='distal',
-                              rate_constant=10.)
+                              rate_constant=10.,
+                              weights_ampa=weights_ampa,
+                              synaptic_delays=syn_delays)
     with pytest.raises(ValueError,
                        match='Allowed drive target locations are:'):
         net.add_poisson_drive('weird_poisson', location='inbetween',
-                              rate_constant=10.)
+                              rate_constant=10.,
+                              weights_ampa=weights_ampa,
+                              synaptic_delays=syn_delays)
     with pytest.raises(ValueError,
                        match='Allowed drive target cell types are:'):
         net.add_poisson_drive('cell_unknown', location='proximal',
                               rate_constant=10.,
-                              weights_ampa={'CA1_pyramidal': 1.})
+                              weights_ampa={'CA1_pyramidal': 1.},
+                              synaptic_delays=.01)
     with pytest.raises(ValueError,
                        match='synaptic_delays is either a common float or '
-                             'needs to be specified as a dict for each cell'):
+                       'needs to be specified as a dict for each of the cell'):
         net.add_poisson_drive('cell_unknown', location='proximal',
                               rate_constant=10.,
                               weights_ampa={'L2_pyramidal': 1.},