bmtool 0.5.1__py3-none-any.whl → 0.5.3__py3-none-any.whl

bmtool/bmplot.py

@@ -3,7 +3,6 @@ Want to be able to take multiple plot names in and plot them all at the same tim
 https://stackoverflow.com/questions/458209/is-there-a-way-to-detach-matplotlib-plots-so-that-the-computation-can-continue
 """
 from .util import util
-
 import argparse,os,sys
 
 import numpy as np
@@ -82,7 +81,6 @@ def total_connection_matrix(config=None,title=None,sources=None, targets=None, s
         title = "All Synapse .mod Files Used"
     if synaptic_info=='3':
         title = "All Synapse .json Files Used"
-
     plot_connection_info(text,num,source_labels,target_labels,title, syn_info=synaptic_info, save_file=save_file)
     return
     
@@ -198,7 +196,7 @@ def probability_connection_matrix(config=None,nodes=None,edges=None,title=None,s
 
     return
 
-def convergence_connection_matrix(config=None,title=None,sources=None, targets=None, sids=None, tids=None, no_prepend_pop=False,save_file=None,convergence=True,method='mean',include_gap=True):
+def convergence_connection_matrix(config=None,title=None,sources=None, targets=None, sids=None, tids=None, no_prepend_pop=False,save_file=None,convergence=True,method='mean+std',include_gap=True):
     """
     Generates connection plot displaying convergence data
     config: A BMTK simulation config 
@@ -208,7 +206,7 @@ def convergence_connection_matrix(config=None,title=None,sources=None, targets=N
     tids: target node identifier
     no_prepend_pop: dictates if population name is displayed before sid or tid when displaying graph
     save_file: If plot should be saved
-    method: 'mean','min','max','stdev' for connvergence plot
+    method: 'mean','min','max','stdev' or 'mean+std' connvergence plot 
     """
     if not config:
         raise Exception("config not defined")
@@ -216,7 +214,7 @@ def convergence_connection_matrix(config=None,title=None,sources=None, targets=N
         raise Exception("Sources or targets not defined")
     return divergence_connection_matrix(config,title ,sources, targets, sids, tids, no_prepend_pop, save_file ,convergence, method,include_gap=include_gap)
 
-def divergence_connection_matrix(config=None,title=None,sources=None, targets=None, sids=None, tids=None, no_prepend_pop=False,save_file=None,convergence=False,method='mean',include_gap=True):
+def divergence_connection_matrix(config=None,title=None,sources=None, targets=None, sids=None, tids=None, no_prepend_pop=False,save_file=None,convergence=False,method='mean+std',include_gap=True):
     """
     Generates connection plot displaying divergence data
     config: A BMTK simulation config 
@@ -226,7 +224,7 @@ def divergence_connection_matrix(config=None,title=None,sources=None, targets=No
     tids: target node identifier
     no_prepend_pop: dictates if population name is displayed before sid or tid when displaying graph
     save_file: If plot should be saved
-    method: 'mean','min','max','stdev' for connvergence plot
+    method: 'mean','min','max','stdev', and 'mean+std' for divergence plot
     """
     if not config:
         raise Exception("config not defined")
@@ -256,17 +254,94 @@ def divergence_connection_matrix(config=None,title=None,sources=None, targets=No
             title = "Maximum "
         elif method == 'std':
             title = "Standard Deviation "
-        else:
+        elif method == 'mean':
             title = "Mean "
+        else: 
+            title = 'Mean + Std '
 
         if convergence:
             title = title + "Synaptic Convergence"
         else:
             title = title + "Synaptic Divergence"
-
-    plot_connection_info(data,data,source_labels,target_labels,title, save_file=save_file)
+    plot_connection_info(syn_info,data,source_labels,target_labels,title, save_file=save_file)
     return
 
+def gap_junction_matrix(config=None,title=None,sources=None, targets=None, sids=None,tids=None, no_prepend_pop=False,save_file=None,type='convergence'):
+    """
+    Generates connection plot displaying gap junction data.
+    config: A BMTK simulation config 
+    sources: network name(s) to plot
+    targets: network name(s) to plot
+    sids: source node identifier 
+    tids: target node identifier
+    no_prepend_pop: dictates if population name is displayed before sid or tid when displaying graph
+    save_file: If plot should be saved
+    type:'convergence' or 'percent' connections
+    """
+    if not config:
+        raise Exception("config not defined")
+    if not sources or not targets:
+        raise Exception("Sources or targets not defined")
+    if type !='convergence' and type!='percent':
+        raise Exception("type must be 'convergence' or 'percent'")
+    sources = sources.split(",")
+    targets = targets.split(",")
+    if sids:
+        sids = sids.split(",")
+    else:
+        sids = []
+    if tids:
+        tids = tids.split(",")
+    else:
+        tids = []
+    syn_info, data, source_labels, target_labels = util.gap_junction_connections(config=config,nodes=None,edges=None,sources=sources,targets=targets,sids=sids,tids=tids,prepend_pop=not no_prepend_pop,type=type)
+    
+    
+    def filter_rows(syn_info, data, source_labels, target_labels):
+        new_syn_info = syn_info
+        new_data = data
+        new_source_labels = source_labels
+        new_target_labels = target_labels
+        for row in new_data:
+            row_index = -1
+            try:
+                if((np.isnan(row).all())): #checks if all of a row is nan
+                    row_index = np.where(np.isnan(new_data)==np.isnan(row))[0][0]  
+            except:
+                row_index = -1
+            finally:          
+                if(all(x==0 for x in row)): #checks if all of a row is zeroes
+                    row_index = np.where(new_data==row)[0][0] 
+                if row_index!=-1:   #deletes corresponding row accordingly in all relevant variables.
+                    new_syn_info = np.delete(new_syn_info,row_index,0) 
+                    new_data = np.delete(new_data,row_index,0)
+                    new_source_labels = np.delete(new_source_labels,row_index)
+        return new_syn_info, new_data,new_source_labels,new_target_labels
+
+    def filter_rows_and_columns(syn_info,data,source_labels,target_labels):
+        syn_info, data, source_labels, target_labels = filter_rows(syn_info, data, source_labels, target_labels)
+        transposed_syn_info = np.transpose(syn_info) #transpose everything and put it in to make sure columns get filtered
+        transposed_data = np.transpose(data)
+        transposed_source_labels = target_labels
+        transposed_target_labels = source_labels
+        syn_info, data, source_labels, target_labels = filter_rows(transposed_syn_info, transposed_data, transposed_source_labels, transposed_target_labels)
+        filtered_syn_info = np.transpose(syn_info) #transpose everything back to original order after filtering.
+        filtered_data = np.transpose(data)
+        filtered_source_labels = target_labels
+        filtered_target_labels = source_labels
+        return filtered_syn_info,filtered_data,filtered_source_labels,filtered_target_labels
+    
+    syn_info, data, source_labels, target_labels = filter_rows_and_columns(syn_info, data, source_labels, target_labels)
+
+    if title == None or title=="":
+        title = 'Gap Junction'
+        if type == 'convergence':
+            title+=' Syn Convergence'
+        elif type == 'percent':
+            title+=' Percent Connectivity'
+    plot_connection_info(syn_info,data,source_labels,target_labels,title, save_file=save_file)
+    return
+    
 def connection_histogram(config=None,nodes=None,edges=None,sources=[],targets=[],sids=[],tids=[],prepend_pop=True,synaptic_info='0',
                       source_cell = None,target_cell = None,include_gap=True):
     """

bmtool/connectors.py

@@ -4,6 +4,7 @@ from scipy.special import erf
 from scipy.optimize import minimize_scalar
 from functools import partial
 import time
+import types
 
 rng = np.random.default_rng()
 
@@ -11,6 +12,13 @@ rng = np.random.default_rng()
 ############################## CONNECT CELLS #################################
 
 # Utility Functions
+def num_prop(ratio, N):
+    """Calculate numbers of total N in proportion to ratio"""
+    ratio = np.asarray(ratio)
+    p = np.cumsum(np.insert(ratio.ravel(), 0, 0))  # cumulative proportion
+    return np.diff(np.round(N / p[-1] * p).astype(int)).reshape(ratio.shape)
+
+
 def decision(prob, size=None):
     """
     Make single random decision based on input probability.
@@ -76,10 +84,10 @@ class DistantDependentProbability(ProbabilityFunction):
         assert(min_dist >= 0 and min_dist < max_dist)
         self.min_dist, self.max_dist = min_dist, max_dist
 
-    def __call__(self, dist):
+    def __call__(self, dist, *arg, **kwargs):
         """Return probability for single distance input"""
         if dist >= self.min_dist and dist <= self.max_dist:
-            return self.probability(dist).item()
+            return self.probability(dist)
         else:
             return 0.
 
@@ -88,7 +96,10 @@ class DistantDependentProbability(ProbabilityFunction):
         dist = np.asarray(dist)
         dec = np.zeros(dist.shape, dtype=bool)
         mask = (dist >= self.min_dist) & (dist <= self.max_dist)
-        dec[mask] = decisions(self.probability(dist[mask]))
+        dist = dist[mask]
+        prob = np.empty(dist.shape)
+        prob[:] = self.probability(dist)
+        dec[mask] = decisions(prob)
         return dec
 
 
@@ -99,7 +110,7 @@ class UniformInRange(DistantDependentProbability):
         super().__init__(min_dist=min_dist, max_dist=max_dist)
         self.p = np.array(p)
         assert(self.p.size == 1)
-        assert(self.p >= 0. and self.p <= 1.)
+        assert(p >= 0. and p <= 1.)
 
     def probability(self, dist):
         return self.p
@@ -127,7 +138,7 @@ class GaussianDropoff(DistantDependentProbability):
             input pmax, and calculate pmax. See calc_pmax_from_ptotal() method.
         ptotal_dist_range: Distance range for calculating pmax when ptotal is
         specified. If not specified, set to range (min_dist, max_dist).
-        dist_type: spherical or cylindrical for distance metric.
+        dist_type: 'spherical' or 'cylindrical' for distance metric.
             Used when ptotal is specified.
 
     Returns:
@@ -215,6 +226,51 @@ class GaussianDropoff(DistantDependentProbability):
             self.probability = probability
 
 
+class NormalizedReciprocalRate(ProbabilityFunction):
+    """Reciprocal connection probability given normalized reciprocal rate.
+    Normalized reciprocal rate is defined as the ratio between the reciprocal
+    connection probability and the connection probability for a randomly
+    connected network where the two unidirectional connections between any pair
+    of neurons are independent. NRR = pr / (p0 * p1)
+    
+    Parameters:
+        NRR: a constant or distance dependent function for normalized reciprocal
+            rate. When being a function, it should be accept vectorized input.
+    Returns:
+        A callable object that returns the probability value.
+    """
+
+    def __init__(self, NRR=1.):
+        self.NRR = NRR if callable(NRR) else lambda *x: NRR
+
+    def probability(self, dist, p0, p1):
+        """Allow numpy array input and return probability in numpy array"""
+        return p0 * p1 * self.NRR(dist)
+
+    def __call__(self, dist, p0, p1, *arg, **kwargs):
+        """Return probability for single distance input"""
+        return self.probability(dist, p0, p1)
+
+    def decisions(self, dist, p0, p1, cond=None):
+        """Return bool array of decisions
+        dist: distance (scalar or array). Will be ignored if NRR is constant.
+        p0, p1: forward and backward probability (scalar or array)
+        cond: A tuple (direction, array of outcomes) representing the condition.
+            Conditional probability will be returned if specified. The condition
+            event is determined by connection direction (0 for forward, or 1 for
+            backward) and outcomes (bool array of whether connection exists).
+        """
+        dist, p0, p1 = map(np.asarray, (dist, p0, p1))
+        pr = np.empty(dist.shape)
+        pr[:] = self.probability(dist, p0, p1)
+        pr = np.clip(pr, a_min=np.fmax(p0 + p1 - 1., 0.), a_max=np.fmin(p0, p1))
+        if cond is not None:
+            mask = np.asarray(cond[1])
+            pr[mask] /= p1 if cond[0] else p0
+            pr[~mask] = 0.
+        return decisions(pr)
+
+
 # Connector Classes
 class AbstractConnector(ABC):
     """Abstract base class for connectors"""
@@ -231,22 +287,6 @@ class AbstractConnector(ABC):
         `connection_rule` method."""
         return NotImplemented
 
-    @staticmethod
-    def is_same_pop(source, target, quick=True):
-        """Whether two NodePool objects direct to the same population"""
-        if quick:
-            # Quick check (compare filter conditions)
-            same = (source.network_name == target.network_name and
-                    source._NodePool__properties ==
-                    target._NodePool__properties)
-        else:
-            # Strict check (compare all nodes)
-            same = (source.network_name == target.network_name and
-                    len(source) == len(target) and
-                    all([s.node_id == t.node_id
-                         for s, t in zip(source, target)]))
-        return same
-
     @staticmethod
     def constant_function(val):
         """Convert a constant to a constant function"""
@@ -255,7 +295,23 @@ class AbstractConnector(ABC):
         return constant
 
 
-# Helper class
+# Helper functions
+def is_same_pop(source, target, quick=False):
+    """Check whether two NodePool objects direct to the same population"""
+    if quick:
+        # Quick check (compare filter conditions)
+        same = (source.network_name == target.network_name and
+                source._NodePool__properties ==
+                target._NodePool__properties)
+    else:
+        # Strict check (compare all nodes)
+        same = (source.network_name == target.network_name and
+                len(source) == len(target) and
+                all([s.node_id == t.node_id
+                     for s, t in zip(source, target)]))
+    return same
+
+
 class Timer(object):
     def __init__(self, unit='sec'):
         if unit == 'ms':
@@ -303,7 +359,7 @@ def rho_2_pr(p0, p1, rho):
 
 class ReciprocalConnector(AbstractConnector):
     """
-    Object for building connections in bmtk network model with reciprocal
+    Object for buiilding connections in bmtk network model with reciprocal
     probability within a single population (or between two populations).
 
     Algorithm:
@@ -388,10 +444,17 @@ class ReciprocalConnector(AbstractConnector):
         symmetric_p1_arg: Whether p0_arg and p1_arg are identical. If this is
             set to True, argument p1_arg will be ignored. This is forced to be
             True when the population is recurrent.
-        pr, pr_arg: Probability of reciprocal connection and its input argument
-            when it is a function, similar to p0, p0_arg, p1, p1_arg. It can be
-            a function when it has an explicit relation with some node
-            properties such as distance.
+        pr, pr_arg: Probability of reciprocal connection and its first input
+            argument when it is a function, similar to p0, p0_arg, p1, p1_arg.
+            It can be a function when it has an explicit relation with some node
+            properties such as distance. A function pr requires two additional
+            positional arguments p0 and p1 even if they are not used, i.e.,
+            pr(pr_arg, p0, p1), just in case pr is dependent on p0 and p1, e.g.,
+            when normalized reciprocal rate NRR = pr/(p0*p1) is given.
+            When pr_arg is a string, the same value as p1_arg will be used for
+            pr_arg if the string contains '1', e.g., '1', 'p1'. Otherwise, e.g.,
+            '', '0', 'p0', p0_arg will be used for pr_arg. Specifying this can
+            avoid recomputing pr_arg when it's given by p0_arg or p1_arg.
         estimate_rho: Whether estimate rho that result in an overall pr. This
             is forced to be False if pr is a function or if rho is specified.
             To estimate rho, all the pairs with possible connections, meaning
@@ -425,6 +488,10 @@ class ReciprocalConnector(AbstractConnector):
             into the connection matrix to reduce memory consumption.
         autapses: Whether to allow connecting a cell to itself. Default: False.
             This is ignored when the population is not recurrent.
+        quick_pop_check: Whether to use quick method to check if source and
+            target populations are the same. Default: False.
+            Quick method checks only whether filter conditions match.
+            Strict method checks whether all node id's match considering order.
         cache_data: Whether to cache the values of p0, p0_arg, p1, p1_arg
             during estimation of rho. This improves performance when
             estimate_rho is True while not creating a significant overhead in
@@ -465,7 +532,7 @@ class ReciprocalConnector(AbstractConnector):
                  pr=0., pr_arg=None, estimate_rho=True, rho=None,
                  dist_range_forward=None, dist_range_backward=None,
                  n_syn0=1, n_syn1=1, autapses=False,
-                 cache_data=True, verbose=True):
+                 quick_pop_check=False, cache_data=True, verbose=True):
         args = locals()
         var_set = ('p0', 'p0_arg', 'p1', 'p1_arg',
                    'pr', 'pr_arg', 'n_syn0', 'n_syn1')
@@ -480,6 +547,7 @@ class ReciprocalConnector(AbstractConnector):
         self.rho = rho
 
         self.autapses = autapses
+        self.quick = quick_pop_check
         self.cache = self.ConnectorCache(cache_data and self.estimate_rho)
         self.verbose = verbose
 
@@ -493,8 +561,8 @@ class ReciprocalConnector(AbstractConnector):
         if self.stage:
             # check whether the correct populations
             if (source is None or target is None or
-                    not self.is_same_pop(source, self.target) or
-                    not self.is_same_pop(target, self.source)):
+                    not is_same_pop(source, self.target, quick=self.quick) or
+                    not is_same_pop(target, self.source, quick=self.quick)):
                 raise ValueError("Source or target population not consistent.")
             # Skip adding nodes for the backward stage.
             return
@@ -508,7 +576,7 @@ class ReciprocalConnector(AbstractConnector):
             raise ValueError("Target nodes do not exists")
 
         # Setup nodes
-        self.recurrent = self.is_same_pop(self.source, self.target, quick=True)
+        self.recurrent = is_same_pop(self.source, self.target, quick=self.quick)
         self.source_ids = [s.node_id for s in self.source]
         self.n_source = len(self.source_ids)
         self.source_list = list(self.source)
@@ -551,6 +619,7 @@ class ReciprocalConnector(AbstractConnector):
             self.enable = enable
             self._output = {}
             self.cache_dict = {}
+            self.set_next_it()
             self.write_mode()
 
         def cache_output(self, func, func_name, cache=True):
@@ -606,9 +675,14 @@ class ReciprocalConnector(AbstractConnector):
                     self.enable = False
             self.mode = 'read'
 
-        def next_it(self):
+        def set_next_it(self):
             if self.enable:
-                self.iter_count += 1
+                def next_it():
+                    self.iter_count += 1
+            else:
+                def next_it():
+                    pass
+            self.next_it = next_it
 
     def node_2_idx_input(self, var_func, reverse=False):
         """Convert a function that accept nodes as input
@@ -703,6 +777,13 @@ class ReciprocalConnector(AbstractConnector):
 
     # *** A sequence of major methods executed during build ***
     def setup_variables(self):
+        # If pr_arg is string, use the same value as p0_arg or p1_arg
+        if isinstance(self.vars['pr_arg'], str):
+            pr_arg_func = 'p1_arg' if '1' in self.vars['pr_arg'] else 'p0_arg'
+            self.vars['pr_arg'] = self.vars[pr_arg_func]
+        else:
+            pr_arg_func = None
+
         callable_set = set()
         # Make constant variables constant functions
         for name, var in self.vars.items():
@@ -718,6 +799,21 @@ class ReciprocalConnector(AbstractConnector):
             var = self.vars[name]
             setattr(self, name, self.node_2_idx_input(var, '1' in name))
 
+        # Set up function for pr_arg if use value from p0_arg or p1_arg
+        if pr_arg_func is None:
+            self._pr_arg = self.pr_arg  # use specified pr_arg
+        else:
+            self._pr_arg_val = 0.  # storing current value from p_arg
+            p_arg = getattr(self, pr_arg_func)
+            def p_arg_4_pr(*args, **kwargs):
+                val = p_arg(*args, **kwargs)
+                self._pr_arg_val = val
+                return val
+            setattr(self, pr_arg_func, p_arg_4_pr)
+            def pr_arg(self, *arg):
+                return self._pr_arg_val
+            self._pr_arg = types.MethodType(pr_arg, self)
+
     def cache_variables(self):
         # Select cacheable attrilbutes
         cache_set = {'p0', 'p0_arg', 'p1', 'p1_arg'}
@@ -825,7 +921,7 @@ class ReciprocalConnector(AbstractConnector):
             if forward:
                 forward = decision(p0)
             if backward:
-                pr = self.pr(self.pr_arg(i, j))
+                pr = self.pr(self._pr_arg(i, j), p0, p1)
                 backward = decision(self.cond_backward(forward, p0, p1, pr))
 
             # Make connection
@@ -849,7 +945,7 @@ class ReciprocalConnector(AbstractConnector):
         if self.verbose:
             self.timer.report('Total time for creating connection matrix')
             if self.wrong_pr:
-                print("\nWarning: Value of 'pr' outside the bounds occurs.\n")
+                print("Warning: Value of 'pr' outside the bounds occurred.\n")
             self.connection_number_info()
 
     def make_connection(self):
@@ -949,7 +1045,7 @@ class ReciprocalConnector(AbstractConnector):
 
 class UnidirectionConnector(AbstractConnector):
     """
-    Object for building unidirectional connections in bmtk network model with
+    Object for buiilding unidirectional connections in bmtk network model with
     given probability within a single population (or between two populations).
 
     Parameters:
@@ -1081,9 +1177,80 @@ class UnidirectionConnector(AbstractConnector):
               % (100. * self.n_conn / self.n_pair))
 
 
-class CorrelatedGapJunction(UnidirectionConnector):
+class GapJunction(UnidirectionConnector):
+    """
+    Object for buiilding gap junction connections in bmtk network model with
+    given probabilities within a single population which is uncorrelated with
+    the recurrent chemical synapses in this population.
+
+    Parameters:
+        p, p_arg: Probability of forward connection and its input argument when
+            it is a function, similar to p0, p0_arg in ReciprocalConnector. It
+            can be a constant or a deterministic function whose value must be
+            within range [0, 1]. When p is constant, the connection is
+            homogenous.
+        verbose: Whether show verbose information in console.
+
+    Returns:
+        An object that works with BMTK to build edges in a network.
+
+    Important attributes:
+        Similar to `UnidirectionConnector`.
     """
-    Object for building gap junction connections in bmtk network model with
+
+    def __init__(self, p=1., p_arg=None, verbose=True):
+        super().__init__(p=p, p_arg=p_arg, verbose=verbose)
+
+    def setup_nodes(self, source=None, target=None):
+        super().setup_nodes(source=source, target=target)
+        if len(self.source) != len(self.target):
+            raise ValueError("Source and target must be the same for "
+                             "gap junction.")
+        self.n_source = len(self.source)
+
+    def make_connection(self, source, target, *args, **kwargs):
+        """Assign gap junction per iteration using one_to_one iterator"""
+        # Initialize in the first iteration
+        if self.iter_count == 0:
+            self.initialize()
+            if self.verbose:
+                src_str, _ = self.get_nodes_info()
+                print("\nStart building gap junction \n  in " + src_str)
+
+        # Consider each pair only once
+        nsyns = 0
+        i, j = divmod(self.iter_count, self.n_source)
+        if i < j:
+            p_arg = self.p_arg(source, target)
+            p = self.p(p_arg)
+            possible = p > 0
+            self.n_poss += possible
+            if possible and decision(p):
+                nsyns = 1
+                sid, tid = source.node_id, target.node_id
+                self.add_conn_prop(sid, tid, p_arg)
+                self.add_conn_prop(tid, sid, p_arg)
+                self.n_conn += 1
+
+        self.iter_count += 1
+
+        # Detect end of iteration
+        if self.iter_count == self.n_pair:
+            if self.verbose:
+                self.connection_number_info()
+                self.timer.report('Done! \nTime for building connections')
+        return nsyns
+
+    def connection_number_info(self):
+        n_pair = self.n_pair
+        self.n_pair = (n_pair - len(self.source)) // 2
+        super().connection_number_info()
+        self.n_pair = n_pair
+
+
+class CorrelatedGapJunction(GapJunction):
+    """
+    Object for buiilding gap junction connections in bmtk network model with
     given probabilities within a single population which could be correlated
     with the recurrent chemical synapses in this population.
 
@@ -1120,13 +1287,6 @@ class CorrelatedGapJunction(UnidirectionConnector):
             conn_prop = conn_prop[0]
         self.ref_conn_prop = conn_prop
 
-    def setup_nodes(self, source=None, target=None):
-        super().setup_nodes(source=source, target=target)
-        if len(self.source) != len(self.target):
-            raise ValueError("Source and target must be the same for "
-                             "gap junction.")
-        self.n_source = len(self.source)
-
     def conn_exist(self, sid, tid):
         trg_dict = self.ref_conn_prop.get(sid)
         if trg_dict is not None and tid in trg_dict:
@@ -1153,7 +1313,7 @@ class CorrelatedGapJunction(UnidirectionConnector):
         if self.iter_count == 0:
             self.initialize()
             if self.verbose:
-                src_str, trg_str = self.get_nodes_info()
+                src_str, _ = self.get_nodes_info()
                 print("\nStart building gap junction \n  in " + src_str)
 
         # Consider each pair only once
@@ -1182,15 +1342,9 @@ class CorrelatedGapJunction(UnidirectionConnector):
                 self.timer.report('Done! \nTime for building connections')
         return nsyns
 
-    def connection_number_info(self):
-        n_pair = self.n_pair
-        self.n_pair = (n_pair - len(self.source)) // 2
-        super().connection_number_info()
-        self.n_pair = n_pair
-
 
 class OneToOneSequentialConnector(AbstractConnector):
-    """Object for building one to one correspondence connections in bmtk
+    """Object for buiilding one to one correspondence connections in bmtk
     network model with between two populations. One of the population can
     consist of multiple sub-populations. These sub-populations need to be added
     sequentially using setup_nodes() and edge_params() methods followed by BMTK
@@ -1337,21 +1491,24 @@ FLUC_STDEV = 0.2  # ms
 DELAY_LOWBOUND = 0.2  # ms must be greater than h.dt
 DELAY_UPBOUND = 2.0  # ms
 
-def syn_dist_delay_feng(source, target,
-                        min_delay=SYN_MIN_DELAY, velocity=SYN_VELOCITY,
-                        fluc_stdev=FLUC_STDEV, connector=None):
+def syn_dist_delay_feng(source, target, min_delay=SYN_MIN_DELAY,
+                        velocity=SYN_VELOCITY, fluc_stdev=FLUC_STDEV,
+                        delay_bound=(DELAY_LOWBOUND, DELAY_UPBOUND),
+                        connector=None):
     """Synpase delay linearly dependent on distance.
     min_delay: minimum delay (ms)
     velocity: synapse conduction velocity (micron/ms)
     fluc_stdev: standard deviation of random Gaussian fluctuation (ms)
+    delay_bound: (lower, upper) bounds of delay (ms)
+    connector: connector object from which to read distance
     """
     if connector is None:
         dist = euclid_dist(target['positions'], source['positions'])
     else:
         dist = connector.get_conn_prop(source.node_id, target.node_id)
     del_fluc = fluc_stdev * rng.normal()
-    delay = dist / SYN_VELOCITY + SYN_MIN_DELAY + del_fluc
-    delay = min(max(delay, DELAY_LOWBOUND), DELAY_UPBOUND)
+    delay = dist / velocity + min_delay + del_fluc
+    delay = min(max(delay, delay_bound[0]), delay_bound[1])
     return delay
 
 
@@ -1373,4 +1530,4 @@ def syn_dist_delay_feng_section_PN(source, target, p=0.9,
 
 def syn_uniform_delay_section(source, target, low=DELAY_LOWBOUND,
                               high=DELAY_UPBOUND, **kwargs):
-    return rng.uniform(low, high)
+    return rng.uniform(low, high)