diff --git a/doc/htmldoc/get-started_index.rst b/doc/htmldoc/get-started_index.rst index 43ae7d9954..2bf2698ac4 100644 --- a/doc/htmldoc/get-started_index.rst +++ b/doc/htmldoc/get-started_index.rst @@ -61,9 +61,10 @@ Next steps: Create your own network model |random| Connect neurons, synapses, and devices ^^^ - - * :ref:`connection_management`: A guide to building connections in NEST + * :ref:`connectivity_concepts`: A guide to define network connectivity in NEST * :ref:`spatial_networks`: A deep dive into building 2D and 3D networks + * :ref:`connection_generator`: Using an external library for generating connections + * :ref:`synapse_spec`: Details on parameterizing synapses .. grid-item-card:: :class-header: sd-d-flex-row sd-align-minor-center sd-bg-info sd-text-white diff --git a/doc/htmldoc/installation/cmake_options.rst b/doc/htmldoc/installation/cmake_options.rst index 80d19a9ea8..a1283d537c 100644 --- a/doc/htmldoc/installation/cmake_options.rst +++ b/doc/htmldoc/installation/cmake_options.rst @@ -313,7 +313,7 @@ follwing switch for the invocation of ``cmake``. It expects either -Dwith-libneurosim=[OFF|ON|] For details on how to use the Connection Generator Interface, see the -:ref:`guide on connection management `. +:ref:`guide on connection generation `. .. _compile_with_python: diff --git a/doc/htmldoc/nest_behavior/running_simulations.rst b/doc/htmldoc/nest_behavior/running_simulations.rst index 069f61b65c..8d4ec785bd 100644 --- a/doc/htmldoc/nest_behavior/running_simulations.rst +++ b/doc/htmldoc/nest_behavior/running_simulations.rst @@ -129,7 +129,7 @@ NEST also has some models that determine the precise time of the threshold crossing during the interval. Please see the documentation on :ref:`precise spike time neurons ` for details about neuron update in continuous time and the -:ref:`documentation on connection management ` +:ref:`documentation on the connectivty concepts ` for how to set the delay when creating synapses. .. _stepped_simulations: diff --git a/doc/htmldoc/networks/spatially_structured_networks.rst b/doc/htmldoc/networks/spatially_structured_networks.rst index dd5b15d367..c982239e53 100644 --- a/doc/htmldoc/networks/spatially_structured_networks.rst +++ b/doc/htmldoc/networks/spatially_structured_networks.rst @@ -1339,7 +1339,7 @@ The following table presents some query functions provided by NEST. +---------------------------------+-----------------------------------------------------+ | ``nest.GetConnections()`` | Retrieve connections (all or for a given | | | source or target); see also | -| | http://www.nest-simulator.org/connection_management.| +| | :ref:`connectivity_concepts`. | +---------------------------------+-----------------------------------------------------+ | ``nest.GetNodes()`` | Returns a NodeCollection of all elements with given | | | properties. | diff --git a/doc/htmldoc/static/css/custom.css b/doc/htmldoc/static/css/custom.css index fb844e52a6..8937a43743 100644 --- a/doc/htmldoc/static/css/custom.css +++ b/doc/htmldoc/static/css/custom.css @@ -141,6 +141,12 @@ figure.align-default { outline-style: groove; } +.center { + + text-align: center; + font-style: italic; +} + /************************************************************************************** * Rules for carousel * ***********************************************************************************/ diff --git a/doc/htmldoc/static/img/All_to_all.png b/doc/htmldoc/static/img/All_to_all.png index 0192745143..042dced33f 100644 Binary files a/doc/htmldoc/static/img/All_to_all.png and b/doc/htmldoc/static/img/All_to_all.png differ diff --git a/doc/htmldoc/static/img/All_to_all_H.png b/doc/htmldoc/static/img/All_to_all_H.png new file mode 100644 index 0000000000..91c4a54541 Binary files /dev/null and b/doc/htmldoc/static/img/All_to_all_H.png differ diff --git a/doc/htmldoc/static/img/Autapse.png b/doc/htmldoc/static/img/Autapse.png new file mode 100644 index 0000000000..e4ffcec664 Binary files /dev/null and b/doc/htmldoc/static/img/Autapse.png differ diff --git a/doc/htmldoc/static/img/Autapse_H.png b/doc/htmldoc/static/img/Autapse_H.png new file mode 100644 index 0000000000..653f2fb8fa Binary files /dev/null and b/doc/htmldoc/static/img/Autapse_H.png differ diff --git a/doc/htmldoc/static/img/Autapse_multapse.png b/doc/htmldoc/static/img/Autapse_multapse.png new file mode 100644 index 0000000000..08c1f89b05 Binary files /dev/null and b/doc/htmldoc/static/img/Autapse_multapse.png differ diff --git a/doc/htmldoc/static/img/Autapse_multapse_v.png b/doc/htmldoc/static/img/Autapse_multapse_v.png new file mode 100644 index 0000000000..93e8eaf0ef Binary files /dev/null and b/doc/htmldoc/static/img/Autapse_multapse_v.png differ diff --git a/doc/htmldoc/static/img/Connection_overview.png b/doc/htmldoc/static/img/Connection_overview.png new file mode 100644 index 0000000000..da21304efc Binary files /dev/null and b/doc/htmldoc/static/img/Connection_overview.png differ diff --git a/doc/htmldoc/static/img/Fixed_indegree.png b/doc/htmldoc/static/img/Fixed_indegree.png index 0279a8b780..ca2313da16 100644 Binary files a/doc/htmldoc/static/img/Fixed_indegree.png and b/doc/htmldoc/static/img/Fixed_indegree.png differ diff --git a/doc/htmldoc/static/img/Fixed_indegree_H.png b/doc/htmldoc/static/img/Fixed_indegree_H.png new file mode 100644 index 0000000000..d77d8aa576 Binary files /dev/null and b/doc/htmldoc/static/img/Fixed_indegree_H.png differ diff --git a/doc/htmldoc/static/img/Fixed_outdegree.png b/doc/htmldoc/static/img/Fixed_outdegree.png index d1342bb61b..ba17f836e0 100644 Binary files a/doc/htmldoc/static/img/Fixed_outdegree.png and b/doc/htmldoc/static/img/Fixed_outdegree.png differ diff --git a/doc/htmldoc/static/img/Fixed_outdegree_H.png b/doc/htmldoc/static/img/Fixed_outdegree_H.png new file mode 100644 index 0000000000..5a3c09fbaa Binary files /dev/null and b/doc/htmldoc/static/img/Fixed_outdegree_H.png differ diff --git a/doc/htmldoc/static/img/Fixed_total_number.png b/doc/htmldoc/static/img/Fixed_total_number.png new file mode 100644 index 0000000000..c19204ad89 Binary files /dev/null and b/doc/htmldoc/static/img/Fixed_total_number.png differ diff --git a/doc/htmldoc/static/img/Fixed_total_number_H.png b/doc/htmldoc/static/img/Fixed_total_number_H.png new file mode 100644 index 0000000000..365100b192 Binary files /dev/null and b/doc/htmldoc/static/img/Fixed_total_number_H.png differ diff --git a/doc/htmldoc/static/img/Multapse.png b/doc/htmldoc/static/img/Multapse.png new file mode 100644 index 0000000000..4d54541b55 Binary files /dev/null and b/doc/htmldoc/static/img/Multapse.png differ diff --git a/doc/htmldoc/static/img/Multapse_H.png b/doc/htmldoc/static/img/Multapse_H.png new file mode 100644 index 0000000000..4844dd30a7 Binary files /dev/null and b/doc/htmldoc/static/img/Multapse_H.png differ diff --git a/doc/htmldoc/static/img/One_to_one.png b/doc/htmldoc/static/img/One_to_one.png index 6d2500d3df..d29040a801 100644 Binary files a/doc/htmldoc/static/img/One_to_one.png and b/doc/htmldoc/static/img/One_to_one.png differ diff --git a/doc/htmldoc/static/img/One_to_one_H.png b/doc/htmldoc/static/img/One_to_one_H.png new file mode 100644 index 0000000000..57bbbc5b65 Binary files /dev/null and b/doc/htmldoc/static/img/One_to_one_H.png differ diff --git a/doc/htmldoc/static/img/Pairwise_bernoulli.png b/doc/htmldoc/static/img/Pairwise_bernoulli.png new file mode 100644 index 0000000000..79ecae3938 Binary files /dev/null and b/doc/htmldoc/static/img/Pairwise_bernoulli.png differ diff --git a/doc/htmldoc/static/img/Pairwise_bernoulli_H.png b/doc/htmldoc/static/img/Pairwise_bernoulli_H.png new file mode 100644 index 0000000000..f2355f1f57 Binary files /dev/null and b/doc/htmldoc/static/img/Pairwise_bernoulli_H.png differ diff --git a/doc/htmldoc/synapses/connection_generator.rst b/doc/htmldoc/synapses/connection_generator.rst new file mode 100644 index 0000000000..dcacacf607 --- /dev/null +++ b/doc/htmldoc/synapses/connection_generator.rst @@ -0,0 +1,53 @@ +.. _connection_generator: + +Connection generator interface +------------------------------ + +.. admonition:: Availability + + This connection rule is only available if NEST was compiled with + :ref:`support for libneurosim `. + +To allow the generation of connectivity by means of an external +library, NEST supports the connection generator interface [2]_. For +more details on this interface, see the git repository of `libneurosim +`_. + +In contrast to the other rules for creating connections, this rule +relies on a Connection Generator object to describe the connectivity +pattern in a library-specific way. The connection generator is handed +to :py:func:`.Connect` under the key ``cg`` of the connection specification +dictionary and evaluated internally. If the connection generator +provides values for connection weights and delays, their respective +indices can be specified under the key ``params_map``. Alternatively, +all synapse parameters can be specified using the synapse +specification argument to ``Connect()``. + +The following listing shows an example for using CSA (`Connection Set Algebra `_ [1]_) in NEST via the connection generator interface and randomly connects 10% of the neurons from +``A`` to the neurons in ``B``, each connection having a weight of +10000.0 pA and a delay of 1.0 ms: + +.. code-block:: python + + import csa + + A = nest.Create('iaf_psc_alpha', 100) + B = nest.Create('iaf_psc_alpha', 100) + + # Create the Connection Generator object + cg = csa.cset(csa.random(0.1), 10000.0, 1.0) + + # Map weight and delay indices to values from cg + params_map = {'weight': 0, 'delay': 1} + + conn_spec = {'rule': 'conngen', 'cg': cg, 'params_map': params_map} + nest.Connect(A, B, conn_spec) + + +References +---------- +.. [1] Djurfeldt M. The Connection-set Algebra—A Novel Formalism for the Representation of Connectivity Structure in Neuronal Network Models. Neuroinformatics. 2012; 10: 287–304. https://doi.org/10.1007/s12021-012-9146-1 +.. [2] Djurfeldt M, Davison AP and Eppler JM (2014). Efficient generation of + connectivity in neuronal networks from simulator-independent + descriptions. Front. Neuroinform. + https://doi.org/10.3389/fninf.2014.00043 diff --git a/doc/htmldoc/synapses/connectivity_concepts.rst b/doc/htmldoc/synapses/connectivity_concepts.rst new file mode 100644 index 0000000000..b50e086cf3 --- /dev/null +++ b/doc/htmldoc/synapses/connectivity_concepts.rst @@ -0,0 +1,608 @@ +.. _connectivity_concepts: + +Connectivity concepts +===================== + +.. grid:: 2 2 7 7 + :gutter: 0 + + .. grid-item-card:: Autapse and multapse + :link: autapse_multapse + :link-type: ref + :img-top: ../static/img/Autapse_multapse_v.png + + + .. grid-item-card:: One to one + :link: one_to_one + :link-type: ref + :img-top: ../static/img/One_to_one.png + + + .. grid-item-card:: All to all + :link: all_to_all + :link-type: ref + :img-top: ../static/img/All_to_all.png + + .. grid-item-card:: Pairwise Bernoulli + :link: pairwise_bernoulli + :link-type: ref + :img-top: ../static/img/Pairwise_bernoulli.png + + + .. grid-item-card:: Fixed total number + :link: fixed_total_number + :link-type: ref + :img-top: ../static/img/Fixed_total_number.png + + + .. grid-item-card:: Fixed in-degree + :link: fixed_indegree + :link-type: ref + :img-top: ../static/img/Fixed_indegree.png + + + .. grid-item-card:: Fixed out-degree + :link: fixed_outdegree + :link-type: ref + :img-top: ../static/img/Fixed_outdegree.png + +.. rst-class:: center + + Basic connection rules commonly used in the computational neuroscience community. For more details, go to the section :ref:`conn_rules` or just click on one of the illustrations. + +This documentation not only describes how to define network connectivity in NEST, but also provides details on connectivity concepts. +The article "Connectivity concepts in neuronal network modeling" [1]_ serves as a permanent reference for a number of connection rules and we suggest to cite it if rules defined there are used. +This documentation instead represents a living reference for these rules, and deviations from and extensions to what is described in the article will be highlighted. + +The same article also introduces a graphical notation for neuronal network diagrams which is curated in the documentation of :doc:`NEST Desktop `. + +:ref:`spatial_networks` are described on a separate page. + +We use the term `connection` to mean a single, atomic edge between network nodes (i.e., neurons or devices). +A `projection` is a group of edges that connects groups of nodes with similar properties (i.e., populations). +To specify network connectivity, each projection is specified by a triplet of source population, target population, and a `connection rule` which defines how to connect the individual nodes. + +Projections are created in NEST with the :py:func:`.Connect` function: + +.. code-block:: python + + nest.Connect(pre, post) + nest.Connect(pre, post, conn_spec) + nest.Connect(pre, post, conn_spec, syn_spec) + +In the simplest case, the function just takes the ``NodeCollections`` ``pre`` and ``post``, defining the nodes of +origin (`sources`) and termination (`targets`) for the connections to be established with the default rule ``all-to-all`` and the synapse model :ref:`static_synapse`. + +Other connectivity patterns can be achieved by explicitly specifying the connection rule with the connectivity specification dictionary ``conn_spec`` which expects a ``rule`` alongside additional rule-specific parameters. +Rules that do not require parameters can be directly provided as string instead of the dictionary; for example, ``nest.Connect(pre, post, 'one_to_one')``. +Examples of parameters might be in- and out-degrees, or the probability for establishing a connection. +All available rules are described in the section :ref:`conn_rules` below. + +Properties of individual connections (i.e., synapses) can be set via the synapse specification dictionary ``syn_spec``. +Parameters like the synaptic weight or delay can be either set values or drawn and combined flexibly from random distributions. +For details on synapse models and their parameters refer to :ref:`synapse_spec`. Note that is also possible to define multiple projections with different synapse properties in the same :py:func:`.Connect` call (see :ref:`collocated_synapses`). + +By using the keyword variant ``nest.Connect(pre, post, syn_spec=syn_spec)``, the `conn_spec` can be omitted in the call to :py:func:`.Connect` and will just take on the default value ``all-to-all``. + +After your connections are established, a quick sanity check is to +look up the number of connections in the network, which can be easily +done using the corresponding kernel attribute: + +.. code-block:: python + + print(nest.num_connections) + +Have a look at the section :ref:`handling_connections` to get more tips on how to examine the connections in greater detail. + + +.. _conn_rules: + +Connection rules +---------------- + +Here we elaborate on the connectivity concepts with details on :ref:`autapse_multapse`, :ref:`deterministic_rules`, :ref:`probabilistic_rules`, and the :ref:`connection_generator` (a method to create connections via CSA, the Connection Set Algebra [2]_). +Finally, we introduce the rule :ref:`tripartite_connectivity` for third-party connections in addition to primary connections between ``pre`` and ``post``. +Each primary rule is described with an illustration, a NEST code example, and mathematical details. +The mathematical details are extracted from the study on connectivity concepts [1]_ and contain a symbol which we recommend to use for describing this type of connectivity, the corresponding expression from CSA, and a formal definition with an algorithmic construction rule and the resulting connectivity distribution. + +.. dropdown:: Mathematical details: General notations and definitions + + | Let :math:`\mathcal{S}=\{s_1,\ldots, s_{N_s}\}` be the ordered set of sources of cardinality :math:`N_s` and :math:`\mathcal{T}=\{t_1,\ldots, t_{N_t}\}` the set of targets of cardinality :math:`N_t`. Then the set of all possible directed edges between members of :math:`\mathcal{S}` and :math:`\mathcal{T}` is given by the Cartesian product :math:`\mathcal{E}_{ST}=\mathcal{S \times T}` of cardinality :math:`N_s\cdot N_t`. + | + | If the source and target populations are identical (:math:`\mathcal{S=T}`) a source can be its own target. We call such a self-connection an :ref:`autapse `. If autapses are not allowed, the target set for any node :math:`i \in \mathcal{S}` is :math:`\mathcal{T=S} \setminus i`, with cardinality :math:`N_t=N_s-1`. If there is more than one edge between a source and target (or from a node to itself), we call this a :ref:`multapse `. + | + | The `degree distribution` :math:`P(k)` is the distribution across nodes of the number of edges per node. In a directed network, the distribution of the number of edges going out of (into) a node is called the `out-degree (in-degree)` distribution. The distributions given below describe the effect of applying a connection rule once to a given :math:`\mathcal{S}-\mathcal{T}` pair. + +.. _autapse_multapse: + +Autapses and multapses +---------------------- + +.. image:: ../static/img/Autapse_multapse.png + :width: 450px + :align: center + +Autapses are self-connections of a node and multapses are multiple connections betweeen the same pair of nodes. + +In the connection specification dictionary ``conn_spec``, the additional switches ``allow_autapses`` (default: +``True``) and ``allow_multapses`` (default: ``True``) can be set to allow or disallow autapses and multapses. + +These switches are only effective during each single call to +:py:func:`.Connect`. Calling the function multiple times with the same set of +neurons might still lead to violations of these constraints, even though the +switches were set to ``False`` in each individual call. + +.. _deterministic_rules: + +Deterministic connection rules +------------------------------ + +Deterministic connection rules establish precisely defined sets of connections without any variability across network realizations. + +.. _one_to_one: + +One-to-one +~~~~~~~~~~ + +.. image:: ../static/img/One_to_one.png + :width: 200px + :align: center + +The `i`\-th node in ``S`` (source) is connected to the `i`\-th node in ``T`` (target). The +``NodeCollections`` of ``S`` and ``T`` have to contain the same number of +nodes. + +.. code-block:: python + + n = 5 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('spike_recorder', n) + nest.Connect(S, T, 'one_to_one') + +.. dropdown:: Mathematical details: One-to-one + + | **Symbol:** :math:`\delta` + | **CSA:** :math:`\delta` + | **Definition:** Each node in :math:`\mathcal{S}` is uniquely connected to one node in :math:`\mathcal{T}`. + | :math:`\mathcal{S}` and :math:`\mathcal{T}` must have identical cardinality :math:`N_s=N_t`. Both sources and targets can be permuted independently even if :math:`\mathcal{S}=\mathcal{T}`. The in- and out-degree distributions are given by :math:`P(K)=\delta_{K,1}`, with Kronecker delta :math:`\delta_{i,j}=1` if :math:`i=j`, and zero otherwise. + + +.. _all_to_all: + +All-to-all +~~~~~~~~~~ + +.. image:: ../static/img/All_to_all.png + :width: 200px + :align: center + +Each node in ``S`` is connected to every node in ``T``. Since +``all_to_all`` is the default, the rule doesn't actually have to be +specified. + +.. code-block:: python + + n, m = 5, 5 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + nest.Connect(S, T, 'all_to_all') + nest.Connect(S, T) # equivalent + +.. dropdown:: Mathematical details: All-to-all + + | **Symbol:** :math:`\Omega` + | **CSA:** :math:`\Omega` + | **Definition:** Each node in :math:`\mathcal{S}` is connected to all nodes in :math:`\mathcal{T}`. + | The resulting edge set is the full edge set :math:`\mathcal{E}_\mathcal{ST}`. The in- and out-degree distributions are :math:`P_\text{in}(K)=\delta_{K,N_s}` for :math:`\mathcal{T}`, and :math:`P_\text{out}(K)=\delta_{K,N_t}` for :math:`\mathcal{S}`, respectively. + +Explicit connections +~~~~~~~~~~~~~~~~~~~~ + +Connections between explicit lists of source-target pairs can be realized in NEST by extracting the respective node ids from the ``NodeCollections`` and using the :ref:`one_to_one` rule. + +.. code-block:: python + + n, m = 5, 5 + S = nest.Create('iaf_psc_alpha', n) # node ids: 1..5 + T = nest.Create('iaf_psc_alpha', m) # node ids: 6..10 + # source-target pairs: (3,8), (4,1), (1,9) + nest.Connect([3,4,1], [8,6,9], 'one_to_one') + +.. dropdown:: Mathematical details: Explicit connections + + | **Symbol:** X + | **CSA:** Not applicable + | **Definition:** Connections are established according to an explicit list of source-target pairs. + | Connectivity is defined by an explicit list of sources and targets, also known as `adjacency list`, as for instance derived from anatomical measurements. It is, hence, not the result of any specific algorithm. An alternative way of representing a fixed connectivity is by means of the `adjacency matrix` :math:`A`, such that :math:`A_{ij}=1` if :math:`j` is connected to :math:`i`, and zero otherwise. We here adopt the common computational neuroscience practice to have the first index :math:`i` denote the target and the second index :math:`j` denote the source node. + + +.. _probabilistic_rules: + +Probabilistic connection rules +------------------------------ + +Probabilistic connection rules establish edges according to a probabilistic rule. Consequently, the exact connectivity varies with realizations. Still, such connectivity leads to specific expectation values of network characteristics, such as degree distributions or correlation structure. + +.. _pairwise_bernoulli: + +Pairwise Bernoulli +~~~~~~~~~~~~~~~~~~ + +.. image:: ../static/img/Pairwise_bernoulli.png + :width: 200px + :align: center + +For each possible pair of nodes from ``S`` and ``T``, a connection is +created with probability ``p``. +Note that multapses cannot be produced with this rule because each possible edge is visited only once, independent of how ``allow_multapses`` is set. + +.. code-block:: python + + n, m, p = 5, 5, 0.5 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'pairwise_bernoulli', 'p': p} + nest.Connect(S, T, conn_spec) + +.. dropdown:: Mathematical details: Pairwise Bernoulli + + | **Symbol:** :math:`p` + | **CSA:** :math:`\rho(p)` + | **Definition:** Each pair of nodes, with source in :math:`\mathcal{S}` and target in :math:`\mathcal{T}`, is connected with probability :math:`p`. + | In its standard form this rule cannot produce multapses since each possible edge is visited only once. If :math:`\mathcal{S=T}`, this concept is similar to Erdős-Rényi-graphs of the `constant probability` `p-ensemble` :math:`G(N,p)`---also called `binomial ensemble` [3]_; the only difference being that we here consider directed graphs, whereas the Erdős-Rényi model is undirected. The distribution of both in- and out-degrees is binomial, + + .. math:: + P(K_\text{in}=K)=\mathcal{B}(K|N_s,p):=\begin{pmatrix}N_s\\K\end{pmatrix}p^{K}(1-p)^{N_s-K} + + and + + .. math:: + P(K_\text{out}=K)=\mathcal{B}(K|N_t,p)\,, + + respectively. + The expected total number of edges equals :math:`\text{E}[N_\text{syn}]=pN_tN_s`. + +Symmetric pairwise Bernoulli +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +For each possible pair of nodes from ``S`` and ``T``, a connection is +created with probability ``p`` from ``S`` to ``T``, as well as a +connection from ``T`` to ``S`` (two connections in total). To use +this rule, ``allow_autapses`` must be ``False``, and ``make_symmetric`` +must be ``True``. + +.. code-block:: python + + n, m, p = 10, 12, 0.2 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'symmetric_pairwise_bernoulli', 'p': p, + 'allow_autapses': False, 'make_symmetric': True} + nest.Connect(S, T, conn_spec) + +.. _pairwise_poisson: + +Pairwise Poisson +~~~~~~~~~~~~~~~~ + +For each possible pair of nodes from ``S`` and ``T``, a number of +connections is created following a Poisson distribution with mean +``pairwise_avg_num_conns``. This means that even for a small +average number of connections between single neurons in ``S`` and +``T`` multiple connections are possible. Thus, for this rule +``allow_multapses`` cannot be ``False``. +The ``pairwise_avg_num_conns`` can be greater than one. + +.. code-block:: python + + n, m, p_avg_num_conns = 10, 12, 0.2 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'pairwise_poisson', + 'pairwise_avg_num_conns': p_avg_num_conns} + nest.Connect(S, T, conn_spec) + +.. _fixed_total_number: + +Random, fixed total number +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. image:: ../static/img/Fixed_total_number.png + :width: 200px + :align: center + + +The nodes in ``S`` are randomly connected with the nodes in ``T`` +such that the total number of connections equals ``N``. + +As multapses are per default allowed and possible with this rule, you can disallow them by adding ``'allow_multapses': False`` to the ``conn_dict``. + +.. code-block:: python + + n, m, N = 5, 5, 10 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'fixed_total_number', 'N': N} + nest.Connect(S, T, conn_spec) + +.. dropdown:: Mathematical details: Random, fixed total number with multapses + + | **Symbol:** :math:`\mathbf{\rho_N}(N_\text{syn})\mathbf{M}(\mathbb{N}_S \times \mathbb{N}_T)` + | **CSA:** :math:`\mathbf{\rho_N}(N_\text{syn})\mathbf{M}(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** :math:`N_\text{syn}\in\{0,\ldots,N_sN_t\}` edges are randomly drawn from the edge set :math:`\mathcal{E}_\mathcal{ST}` with replacement. + | If multapses are allowed, there are :math:`\begin{pmatrix}N_sN_t+N_\text{syn}-1\\N_\text{syn}\end{pmatrix}` possible networks for any given number :math:`N_\text{syn}\leq N_sN_t`. + | Because exactly :math:`N_\text{syn}` connections are distributed across :math:`N_t` targets with replacement, the joint in-degree distribution is multinomial, + + .. math:: + \begin{equation}\label{eq:randfixKm} + \begin{split} + &P(K_{\text{in},1}=K_1,\ldots,K_{\text{in},N_t}=K_{N_t})\\ + & \quad \quad \quad=\begin{cases} + \frac{N_\text{syn}!}{K_1!...K_{N_t}!} \,p^{N_\text{syn}} & \text{if}\,\,\sum_{j=1}^{N_t} K_j = N_\text{syn}\\ + \quad\quad 0 & \text{otherwise}\end{cases}\, + \end{split} + \end{equation} + + with :math:`p=1/N_t`. + + The out-degrees have an analogous multinomial distribution :math:`P(K_{\text{out},1}=K_1,\ldots,K_{\text{out},N_s}=K_{N_s})`, with :math:`p=1/N_s` and sources and targets switched. The marginal distributions are binomial distributions :math:`P(K_{\text{in},j}=K)= \mathcal{B}(K|N_\text{syn},1/N_t)` and :math:`P(K_{\text{out},j}=K)= \mathcal{B}(K|N_\text{syn},1/N_s)`, respectively. + + The :math:`\mathbf{M}`-operator of CSA should not be confused with the ":math:`M`" indicating that multapses are allowed in our symbolic notation. + + + +.. dropdown:: Mathematical details: Random, fixed total number without multapses + + | **Symbol:** :math:`N_\text{syn} \cancel{M}` + | **CSA:** :math:`\mathbf{\rho_{N}}(N_\text{syn})(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** :math:`N_\text{syn}\in\{0,\ldots,N_sN_t\}` edges are randomly drawn from the edge set :math:`\mathcal{E}_\mathcal{ST}` without replacement. + | For :math:`\mathcal{S}=\mathcal{T}` this is a directed graph generalization of Erdős-Rényi graphs of the `constant number of edges` :math:`N_\text{syn}`-ensemble :math:`G(N,N_\text{syn})` [4]_. There are :math:`\begin{pmatrix}N_s N_t\\N_\text{syn}\end{pmatrix}` possible networks for any given number :math:`N_\text{syn}\leq N_sN_t`, which all have the same probability. The resulting in- and out-degree distributions are multivariate hypergeometric distributions. + + .. math:: + \begin{split} + &P(K_{\text{in},1}=K_1,\ldots,K_{\text{in},N_t}=K_{N_t})\\ + & \quad \quad \quad = \begin{cases} + \prod_{j=1}^{N_t} \begin{pmatrix} N_s\\K_j\end{pmatrix}\Bigg/\begin{pmatrix} N_sN_t\\N_\text{syn}\end{pmatrix} + & \text{if}\,\,\sum_{j=1}^{N_t} K_j = N_\text{syn}\\ + \phantom{bl}0 & \text{otherwise}\end{cases}\,, + \end{split} + + and analogously :math:`P(K_{\text{out},1}=K_1,\ldots,K_{\text{out},N_s}=K_{N_s})` + with :math:`K_\text{out}` instead of :math:`K_\text{in}` and source and target indices switched. + + The marginal distributions, i.e., the probability distribution for any specific node :math:`j` to have in-degree :math:`K_j`, are hypergeometric distributions + + .. math:: + P(K_{\text{in},j}=K_j)= + \begin{pmatrix} N_s\\K_j \end{pmatrix} \begin{pmatrix}N_sN_t-1 \\ + N_\text{syn}-K_j \end{pmatrix}\Bigg/\begin{pmatrix}N_sN_t + \\ N_\text{syn}\end{pmatrix} \,, + + with sources and targets switched for :math:`P(K_{\text{out},j}=K_j)`. + +.. _fixed_indegree: + +Random, fixed in-degree +~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +.. image:: ../static/img/Fixed_indegree.png + :width: 200px + :align: center + +The nodes in ``S`` are randomly connected with the nodes in ``T`` such +that each node in ``T`` has a fixed ``indegree`` of ``N``. + +As multapses are per default allowed and possible with this rule, you can disallow them by adding ``'allow_multapses': False`` to the ``conn_dict``. + +.. code-block:: python + + n, m, N = 5, 5, 2 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'fixed_indegree', 'indegree': N} + nest.Connect(S, T, conn_spec) + +.. dropdown:: Mathematical details: Random, fixed in-degree with multapses + + | **Symbol:** :math:`K_\text{in}, M` + | **CSA:** :math:`\mathbf{\rho_1}(K)\mathbf{M}(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** Each target node in :math:`\mathcal{T}` is connected to :math:`K_\text{in}` nodes in :math:`\mathcal{S}` randomly chosen with replacement. + | :math:`N_s` is the number of source nodes from which exactly :math:`K_\text{in}` connections are drawn with equal probability :math:`p=1/N_s` for each of the :math:`N_t` target nodes :math:`t_i\in\mathcal{T}`. The in-degree distribution is by definition :math:`P(K)=\delta_{K,K_\text{in}}`. To obtain the out-degree distribution, we observe that because multapses are allowed, drawing :math:`N_t` times :math:`K_{\text{in},i}=K_\text{in}` from :math:`\mathcal{S}` is equivalent to drawing :math:`N_t K_\text{in}` times with replacement from :math:`\mathcal{S}`. This procedure yields a multinomial distribution of the out-degrees :math:`K_{\text{out},j}` of source nodes :math:`s_j\in\mathcal{S}` [5]_, i.e., + + .. math:: + \begin{equation}\label{eq:rfin} + \begin{split} + &P(K_{\text{out},1}=K_1,\ldots,K_{\text{out},N_s}=K_{N_s})\\ + & \quad \quad \quad =\begin{cases} + \frac{(N_tK_\text{in})!}{K_1!...K_{N_s}!} p^{N_tK_\text{in}} & \text{if}\,\,\sum_{j=1}^{N_s} K_j = N_tK_\text{in}\\ + \quad\quad 0 & \text{otherwise}\end{cases} + \end{split} + \end{equation} + + The marginal distributions are binomial distributions + + .. math:: + \begin{equation}\label{eq:rfinmarg} + P(K_{\text{out},j}=K)= \mathcal{B}(K|N_tK_\text{in},1/N_s)\,. + \end{equation} + + +.. dropdown:: Mathematical details: Random, fixed in-degree without multapses + + | **Symbol:** :math:`K_\text{in}, \cancel{M}` + | **CSA:** :math:`{\rho_1}(K)(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** Each target node in :math:`\mathcal{T}` is connected to :math:`K_\text{in}` nodes in :math:`\mathcal{S}` randomly chosen without replacement. + | The in-degree distribution is by definition :math:`P(K)=\delta_{K,K_\text{in}}`. To obtain the out-degree distribution, observe that after one target node has drawn its :math:`K_\text{out}` sources the joint probability distribution of out-degrees :math:`K_{\text{out},j}` is multivariate-hypergeometric such that + + .. math:: + \begin{equation}\label{eq:hypmult} + \begin{split} + &P(K_{\text{out},1}=K_1, \ldots,K_{\text{out},N_s}=K_{N_s})\\ + & \quad \quad \quad= \begin{cases} + \prod_{j=1}^{N_s} \begin{pmatrix} 1\\K_j\end{pmatrix}\Bigg/\begin{pmatrix} N_s\\K_\text{in}\end{pmatrix} + & \text{if}\,\,\sum_{j=1}^{N_s} K_j = K_\text{in}\\ + \phantom{bl}0 & \text{otherwise}\end{cases}\,, \qquad (1) + \end{split} + \end{equation} + + where :math:`\forall_j\,K_j\in\{0,1\}`. + The marginal distributions are hypergeometric distributions + + .. math:: + \begin{eqnarray}\label{eq:hypmarg} + P(K_{\text{out},j}=K)= + \begin{pmatrix} 1\\K \end{pmatrix} \begin{pmatrix}N_s-1 \\ + K_\text{in}-K \end{pmatrix}\Bigg/\begin{pmatrix}N_s + \\ K_\text{in}\end{pmatrix} = \text{Ber}(K_\text{in}/N_s)\,, \qquad (2) + \end{eqnarray} + + with :math:`\text{Ber}(p)` denoting the Bernoulli distribution with parameter :math:`p`, because :math:`K\in\{0,1\}`. + The full joint distribution is the sum of :math:`N_t` independent instances of equation (1). + + +.. _fixed_outdegree: + +Random, fixed out-degree +~~~~~~~~~~~~~~~~~~~~~~~~ + +.. image:: ../static/img/Fixed_outdegree.png + :width: 200px + :align: center + +The nodes in ``S`` are randomly connected with the nodes in ``T`` such +that each node in ``S`` has a fixed ``outdegree`` of ``N``. + +As multapses are per default allowed and possible with this rule, you can disallow them by adding ``'allow_multapses': False`` to the ``conn_dict``. + +.. code-block:: python + + n, m, N = 5, 5, 2 + S = nest.Create('iaf_psc_alpha', n) + T = nest.Create('iaf_psc_alpha', m) + conn_spec = {'rule': 'fixed_outdegree', 'outdegree': N} + nest.Connect(S, T, conn_spec) + +.. dropdown:: Mathematical details: Random, fixed out-degree with multapses + + | **Symbol:** :math:`K_\text{out}, M` + | **CSA:** :math:`\mathbf{\rho_0}(K)\mathbf{M}(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** Each source node in :math:`\mathcal{S}` is connected to :math:`K_\text{out}` nodes in :math:`\mathcal{T}` randomly chosen with replacement. + | By definition, the out-degree distribution is a :math:`P(K)=\delta_{K,K_\text{out}}`. The respective in-degree distribution and marginal distributions are obtained by switching source and target indices, and replacing :math:`K_\text{out}` with :math:`K_\text{in}` in equation from :ref:`fixed_indegree` [5]_. + +.. dropdown:: Mathematical details: Random, fixed out-degree without multapses + + | **Symbol:** :math:`K_\text{out},\cancel{M}` + | **CSA:** :math:`\mathbf{\rho_0}(K)(\mathbb{N}_S \times \mathbb{N}_T)` + | **Definition:** Each source node in :math:`S` is connected to :math:`K_\text{out}` nodes in :math:`\mathcal{T}` randomly chosen without replacement. + | The out-degree distribution is by definition :math:`P(K)=\delta_{K,K_\text{out}}`, while the in-degree distribution is obtained by switching source and target indices, and replacing :math:`K_\text{out}` with :math:`K_\text{in}` in equation (2) from :ref:`fixed_indegree`. + + +.. _tripartite_connectivity: + +Tripartite Bernoulli with pool +------------------------------ + +For each possible pair of nodes from a source ``NodeCollection`` (e.g., a neuron population ``S``) +and a target ``NodeCollection`` (e.g., a neuron population ``T``), a connection is +created with probability ``p_primary``, and these connections are +called 'primary' connections. For each primary connection, a +third-party connection pair involving a node from a third ``NodeCollection`` +(e.g., an astrocyte population ``A``) is created with the conditional probability +``p_third_if_primary``. This connection pair includes a connection +from the ``S`` node to the ``A`` node, and a connection from the ``A`` node to the +``T`` node. The ``A`` node to connect to is chosen +at random from a pool, a subset of the nodes in ``A``. By default, +this pool is all of ``A``. + +Pool formation is controlled by parameters ``pool_type``, which can be ``'random'`` +(default) or ``'block'``, and ``pool_size``, which must be between 1 +and the size of ``A`` (default). For random pools, for each node from +``T``, ``pool_size`` nodes from ``A`` are chosen randomly without +replacement. + +For block pools, two variants exist. Let ``N_T`` and ``N_A`` be the number of +nodes in ``T`` and ``A``, respectively. If ``pool_size == 1``, the +first ``N_T/N_A`` nodes in ``T`` are assigned the first node in +``A`` as their pool, the second ``N_T/N_A`` nodes in ``T`` the +second node in ``A`` and so forth. In this case, ``N_T`` must be a +multiple of ``N_A``. If ``pool_size > 1``, the first ``pool_size`` +elements of ``A`` are the pool for the first node in ``T``, the +second ``pool_size`` elements of ``A`` are the pool for the second +node in ``T`` and so forth. In this case, ``N_T * pool_size == N_A`` +is required. + +The following figure and code demonstrate three use case examples with +``pool_type`` being ``'random'`` or ``'block'``: + +.. image:: ../static/img/tripartite_pool_type.svg + :align: center + +(A) In the example of ``'random'`` pool type, each node in ``T`` can be connected with +up to two randomly selected nodes in ``A`` (given ``pool_size == 2``). + +.. code-block:: python + + N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 6, 3, 0.2, 1.0 + pool_type, pool_size = 'random', 2 + S = nest.Create('aeif_cond_alpha_astro', N_S) + T = nest.Create('aeif_cond_alpha_astro', N_T) + A = nest.Create('astrocyte_lr_1994', N_A) + conn_spec = {'rule': 'tripartite_bernoulli_with_pool', + 'p_primary': p_primary, + 'p_third_if_primary': p_third_if_primary, + 'pool_type': pool_type, + 'pool_size': pool_size} + syn_specs = {'third_out': 'sic_connection'} + nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) + +(B) In +the first example of ``'block'`` pool type, let ``N_T/N_A`` = 2, +then each node in ``T`` can be connected with one node in ``A`` +(``pool_size == 1`` is required because ``N_A < N_T``), and each node in +``A`` can be connected with up to two nodes in ``T``. + +.. code-block:: python + + N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 6, 3, 0.2, 1.0 + pool_type, pool_size = 'block', 1 + S = nest.Create('aeif_cond_alpha_astro', N_S) + T = nest.Create('aeif_cond_alpha_astro', N_T) + A = nest.Create('astrocyte_lr_1994', N_A) + conn_spec = {'rule': 'tripartite_bernoulli_with_pool', + 'p_primary': p_primary, + 'p_third_if_primary': p_third_if_primary, + 'pool_type': pool_type, + 'pool_size': pool_size} + syn_specs = {'third_out': 'sic_connection'} + nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) + +(C) In the second example +of ``'block'`` pool type, let ``N_A/N_T`` = 2, then each node in +``T`` can be connected with up to two nodes in ``A`` (``pool_size == 2`` is +required because ``N_A/N_T`` = 2), and each node in ``A`` can be +connected to one node in ``T``. + +.. code-block:: python + + N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 3, 6, 0.2, 1.0 + pool_type, pool_size = 'block', 2 + S = nest.Create('aeif_cond_alpha_astro', N_S) + T = nest.Create('aeif_cond_alpha_astro', N_T) + A = nest.Create('astrocyte_lr_1994', N_A) + conn_spec = {'rule': 'tripartite_bernoulli_with_pool', + 'p_primary': p_primary, + 'p_third_if_primary': p_third_if_primary, + 'pool_type': pool_type, + 'pool_size': pool_size} + syn_specs = {'third_out': 'sic_connection'} + nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) + + +References +---------- + +.. [1] Senk J, Kriener B, Djurfeldt M, Voges N, Jiang HJ, et al. (2022) Connectivity concepts in neuronal network modeling. PLOS Computational Biology 18(9): e1010086. https://doi.org/10.1371/journal.pcbi.1010086 +.. [2] Djurfeldt M. The Connection-set Algebra—A Novel Formalism for the Representation of Connectivity Structure in Neuronal Network Models. Neuroinformatics. 2012; 10: 287–304. https://doi.org/10.1007/s12021-012-9146-1 +.. [3] Albert R, Barabási AL. Statistical mechanics of complex networks. Rev Mod Phys. 2002; 74: 47–97. https://doi.org/10.1103/RevModPhys.74.47 +.. [4] Erdős P, Rényi A. On random graphs. Publications Mathematicae. 1959; 6: 290–297. +.. [5] Hjertholm D. Statistical tests for connection algorithms for structured neural networks [master’s thesis]. Norwegian University of Life Sciences. Ås, Norway; 2013. Available from: http://hdl.handle.net/11250/189117 diff --git a/doc/htmldoc/synapses/handling_connections.rst b/doc/htmldoc/synapses/handling_connections.rst index c72c8fabf9..4c1a60e121 100644 --- a/doc/htmldoc/synapses/handling_connections.rst +++ b/doc/htmldoc/synapses/handling_connections.rst @@ -1,7 +1,10 @@ .. _handling_connections: -How to handle connections (synapses) -===================================== +Working with connections +========================= + +Here, we describe how to inspect and modify already created connections. +:ref:`connectivity_concepts` describes how to create new connections (for using an external library see :ref:`connection_generator`) and :ref:`synapse_spec` how to parameterize synapses as they are created. Just like a NodeCollection is a container for node IDs, a SynapseCollection is a container for connections. In NEST 3, when you call :py:func:`.GetConnections` a diff --git a/doc/htmldoc/synapses/connection_management.rst b/doc/htmldoc/synapses/synapse_specification.rst similarity index 59% rename from doc/htmldoc/synapses/connection_management.rst rename to doc/htmldoc/synapses/synapse_specification.rst index b9c782f408..f12abd2b95 100644 --- a/doc/htmldoc/synapses/connection_management.rst +++ b/doc/htmldoc/synapses/synapse_specification.rst @@ -1,429 +1,10 @@ -.. _connection_management: +.. _synapse_spec: -Connection Management +Synapse specification ===================== -Connections between populations of neurons and between neurons and -devices for stimulation and recording in NEST are created with the -:py:func:`.Connect` function. Although each connection is internally -represented individually, you can use a single call to ``Connect()`` -to create many connections at the same time. In the simplest case, the -function just takes two NodeCollections containing the source and -target nodes that will be connected in an all-to-all fashion. - -Each call to the function will establish the connectivity between pre- -and post-synaptic populations according to a certain pattern or -rule. The desired pattern is specified by simply stating the rule name -as third argument to ``Connect()``, or by setting the key ``rule`` in -the connectivity specification dictionary ``conn_spec`` alongside -additional rule-specific parameters. All available patterns are -described in the section :ref:`Connection Rules ` below. - -To specify the properties for the individual connections, a synapse -specification ``syn_spec`` can be given to ``Connect()``. This can -also just be the name of the synapse model to be used, an object -defining :ref:`collocated synapses `, or a -dictionary, with optional parameters for the connections. - -The ``syn_spec`` is given as the fourth argument to the ``Connect()`` -function. Parameters like the synaptic weight or delay can be either -set values or drawn and combined flexibly from random distributions. -More information about synapse models and their parameters can -be found in the section :ref:`Synapse Specification `. - -The :py:func:`.Connect` function can be called in any of the following ways: - -.. code-block:: python - - Connect(pre, post) - Connect(pre, post, conn_spec) - Connect(pre, post, conn_spec, syn_spec) - -``pre`` and ``post`` are ``NodeCollections``, defining the nodes of -origin (`sources`) and termination (`targets`) for the connections to -be established. - -If ``conn_spec`` is not specified, the default connection rule -``all_to_all`` will be used. - -The synapse specification ``syn_spec`` defaults to the synapse model -:hxt_ref:`static_synapse`. By using the keyword variant (``Connect(pre, post, -syn_spec=syn_spec_dict)``), ``conn_spec`` can be omitted in the call -to :py:func:`.Connect` and will just take on the default value. - -After your connections are established, a quick sanity check is to -look up the number of connections in the network, which can be easily -done using the corresponding kernel attribute: - -.. code-block:: python - - print(nest.num_connections) - -Have a look at the :ref:`inspecting_connections` section further down -to get more tips on how to examine the connections in greater detail. - -Multapses and autapses ----------------------- - -In the connection specification dictionary (containing the rule name and rule- -specific parameters), the additional switch ``allow_autapses`` (default: -``True``) can be set to allow or disallow self-connections. - -Likewise, ``allow_multapses`` (default: ``True``) can be used to specify if -multiple connections between the same pair of neurons are allowed or not. - -These switches are only effective during each single call to -:py:func:`.Connect`. Calling the function multiple times with the same set of -neurons might still lead to violations of these constraints, even though the -switches were set to `False` in each individual call. - -.. _conn_rules: - -Connection Rules ----------------- - -Connection rules are specified using the ``conn_spec`` parameter of -:py:func:`.Connect`, which can be either just a string naming a connection -rule, or a dictionary containing a rule specification. Only connection -rules requiring no parameters can be given as strings, for all other -rules, a dictionary specifying the rule and its parameters is -required. Examples for such parameters might be in- and out-degrees, -or the probability for establishing a connection. A description of -all connection rules available in NEST is available below. - -all-to-all -~~~~~~~~~~ - -.. image:: ../static/img/All_to_all.png - :width: 200px - :align: center - -Each node in ``A`` is connected to every node in ``B``. Since -``all_to_all`` is the default, the rule doesn't actually have to be -specified. - -.. code-block:: python - - n, m = 10, 12 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - nest.Connect(A, B, 'all_to_all') - nest.Connect(A, B) # equivalent - -.. _conn_builder_conngen: - -conngen -~~~~~~~ - -.. admonition:: Availability - - This connection rule is only available if NEST was compiled with - :ref:`support for libneurosim `. - -To allow the generation of connectivity by means of an external -library, NEST supports the Connection Generator Interface [1]_. For -more details on this interface, see the Git repository of `libneurosim -`_. - -In contrast to the other rules for creating connections, this rule -relies on a Connection Generator object to describe the connectivity -pattern in a library-specific way. The Connection Generator is handed -to :py:func:`.Connect` under the key ``cg`` of the connection specification -dictionary and evaluated internally. If the Connection Generator -provides values for connection weights and delays, their respective -indices can be specified under the key ``params_map``. Alternatively, -all synapse parameters can be specified using the synapse -specification argument to ``Connect()``. - -The following listing shows an example for using the `Connection-Set -Algebra `_ in NEST via the Connection -Generator Interface and randomly connects 10% of the neurons from -``A`` to the neurons in ``B``, each connection having a weight of -10000.0 pA and a delay of 1.0 ms: - -.. code-block:: python - - A = nest.Create('iaf_psc_alpha', 100) - B = nest.Create('iaf_psc_alpha', 100) - - # Create the Connection Generator object - import csa - cg = csa.cset(csa.random(0.1), 10000.0, 1.0) - - # Map weight and delay indices to values from cg - params_map = {'weight': 0, 'delay': 1} - - conn_spec_dict = {'rule': 'conngen', 'cg': cg, 'params_map': params_map} - nest.Connect(A, B, conn_spec_dict) - -fixed indegree -~~~~~~~~~~~~~~ - -.. image:: ../static/img/Fixed_indegree.png - :width: 200px - :align: center - -The nodes in ``A`` are randomly connected with the nodes in ``B`` such -that each node in ``B`` has a fixed :hxt_ref:`indegree` of ``N``. - -.. code-block:: python - - n, m, N = 10, 12, 2 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'fixed_indegree', 'indegree': N} - nest.Connect(A, B, conn_spec_dict) - -fixed outdegree -~~~~~~~~~~~~~~~ - -.. image:: ../static/img/Fixed_outdegree.png - :width: 200px - :align: center - -The nodes in ``A`` are randomly connected with the nodes in ``B`` such -that each node in ``A`` has a fixed :hxt_ref:`outdegree` of ``N``. - -.. code-block:: python - - n, m, N = 10, 12, 2 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'fixed_outdegree', 'outdegree': N} - nest.Connect(A, B, conn_spec_dict) - -fixed total number -~~~~~~~~~~~~~~~~~~ - -The nodes in ``A`` are randomly connected with the nodes in ``B`` -such that the total number of connections equals ``N``. - -.. code-block:: python - - n, m, N = 10, 12, 30 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'fixed_total_number', 'N': N} - nest.Connect(A, B, conn_spec_dict) - -one-to-one -~~~~~~~~~~ - -.. image:: ../static/img/One_to_one.png - :width: 200px - :align: center - -The `i`\ th node in ``A`` is connected to the `i`\ th node in ``B``. The -NodeCollections of ``A`` and ``B`` have to contain the same number of -nodes. - -.. code-block:: python - - n = 10 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('spike_recorder', n) - nest.Connect(A, B, 'one_to_one') - -pairwise bernoulli -~~~~~~~~~~~~~~~~~~ - -For each possible pair of nodes from ``A`` and ``B``, a connection is -created with probability ``p``. - -.. code-block:: python - - n, m, p = 10, 12, 0.2 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'pairwise_bernoulli', 'p': p} - nest.Connect(A, B, conn_spec_dict) - -symmetric pairwise bernoulli -~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -For each possible pair of nodes from ``A`` and ``B``, a connection is -created with probability ``p`` from ``A`` to ``B``, as well as a -connection from ``B`` to ``A`` (two connections in total). To use -this rule, ``allow_autapses`` must be ``False``, and ``make_symmetric`` -must be ``True``. - -.. code-block:: python - - n, m, p = 10, 12, 0.2 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'symmetric_pairwise_bernoulli', 'p': p, - 'allow_autapses': False, 'make_symmetric': True} - nest.Connect(A, B, conn_spec_dict) - -pairwise poisson -~~~~~~~~~~~~~~~~ - -For each possible pair of nodes from ``A`` and ``B``, a number of -connections is created following a Poisson distribution with mean -``pairwise_avg_num_conns``. This means that even for a small -average number of connections between single neurons in ``A`` and -``B`` multiple connections are possible. Thus, for this rule -``allow_multapses`` cannot be ``False``. -The ``pairwise_avg_num_conns`` can be greater than one. - -.. code-block:: python - - n, m, p_avg_num_conns = 10, 12, 0.2 - A = nest.Create('iaf_psc_alpha', n) - B = nest.Create('iaf_psc_alpha', m) - conn_spec_dict = {'rule': 'pairwise_poisson', - 'pairwise_avg_num_conns': p_avg_num_conns} - nest.Connect(A, B, conn_spec_dict) - -.. _tripartite_connectivity: +This page is about parameterizing synapses. See :ref:`connectivity_concepts` for specifying connections (for using an external library see :ref:`connection_generator`) and :ref:`handling_connections` for inspecting and modifying ``SynapseCollections``. -Tripartite connectivity ------------------------ - -NEST supports creating connections of three node populations using the -:py:func:`.TripartiteConnect` function: - -.. code-block:: python - - nest.TripartiteConnect(pre, post, third, conn_spec) - nest.TripartiteConnect(pre, post, third, conn_spec, syn_specs) - -``pre``, ``post``, and ``third`` are ``NodeCollections``, defining the nodes of -origin (`sources`) and termination (`targets`) as well as the third -factor population to be included. Connections will be established from ``pre`` to both ``third`` and ``post``, and from ``third`` to ``post``. Details of the connections created depend on -the connection rule used. - -``conn_spec`` must be provided and must specify a tripartite -connection rule, e.g., :ref:`tripartite Bernoulli with pool `. - -``syn_specs`` is a dictionary of the form - -.. code-block:: python - - {'primary': , - 'third_in': , - 'third_out': } - -where the individual ``syn_spec`` elements follow the same rules as -for the :py:func:`.Connect` function. Any of the three elements can be -left out, in which case the synapse specification defaults to -``'static_synapse'``. The ``'primary'`` synapse specification applies -to connections from ``pre`` to ``post`` nodes, the ``'third_in'`` -specification to connections from ``pre`` to ``third`` nodes and -the ``'third_out'`` specification to connections from ``third`` to -``post`` nodes. - -.. admonition: - - Tripartite connectivity is a new feature. Please expect some adjustments to - the syntax and semantics for the tripartite connectivity in the next NEST releases. - - -.. _tripartite_bernoulli_with_pool: - -Tripartite Bernoulli with pool -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ - -For each possible pair of nodes from a source ``NodeCollection`` (e.g., a neuron population ``S``) -and a target ``NodeCollection`` (e.g., a neuron population ``T``), a connection is -created with probability ``p_primary``, and these connections are -called 'primary' connections. For each primary connection, a -third-party connection pair involving a node from a third ``NodeCollection`` -(e.g., an astrocyte population ``A``) is created with the conditional probability -``p_third_if_primary``. This connection pair includes a connection -from the ``S`` node to the ``A`` node, and a connection from the ``A`` node to the -``T`` node. The ``A`` node to connect to is chosen -at random from a pool, a subset of the nodes in ``A``. By default, -this pool is all of ``A``. - -Pool formation is controlled by parameters ``pool_type``, which can be ``'random'`` -(default) or ``'block'``, and ``pool_size``, which must be between 1 -and the size of ``A`` (default). For random pools, for each node from -``T``, ``pool_size`` nodes from ``A`` are chosen randomly without -replacement. - -For block pools, two variants exist. Let ``N_T`` and ``N_A`` be the number of -nodes in ``T`` and ``A``, respectively. If ``pool_size == 1``, the -first ``N_T/N_A`` nodes in ``T`` are assigned the first node in -``A`` as their pool, the second ``N_T/N_A`` nodes in ``T`` the -second node in ``A`` and so forth. In this case, ``N_T`` must be a -multiple of ``N_A``. If ``pool_size > 1``, the first ``pool_size`` -elements of ``A`` are the pool for the first node in ``T``, the -second ``pool_size`` elements of ``A`` are the pool for the second -node in ``T`` and so forth. In this case, ``N_T * pool_size == N_A`` -is required. - -The following code and figure demonstrate three use case examples with -``pool_type`` being ``'random'`` or ``'block'``: - -.. code-block:: python - - N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 6, 3, 0.2, 1.0 - pool_type, pool_size = 'random', 2 - S = nest.Create('aeif_cond_alpha_astro', N_S) - T = nest.Create('aeif_cond_alpha_astro', N_T) - A = nest.Create('astrocyte_lr_1994', N_A) - conn_spec = {'rule': 'tripartite_bernoulli_with_pool', - 'p_primary': p_primary, - 'p_third_if_primary': p_third_if_primary, - 'pool_type': pool_type, - 'pool_size': pool_size} - syn_specs = {'third_out': 'sic_connection'} - nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) - - -.. code-block:: python - - N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 6, 3, 0.2, 1.0 - pool_type, pool_size = 'block', 1 - S = nest.Create('aeif_cond_alpha_astro', N_S) - T = nest.Create('aeif_cond_alpha_astro', N_T) - A = nest.Create('astrocyte_lr_1994', N_A) - conn_spec = {'rule': 'tripartite_bernoulli_with_pool', - 'p_primary': p_primary, - 'p_third_if_primary': p_third_if_primary, - 'pool_type': pool_type, - 'pool_size': pool_size} - syn_specs = {'third_out': 'sic_connection'} - nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) - - -.. code-block:: python - - N_S, N_T, N_A, p_primary, p_third_if_primary = 6, 3, 6, 0.2, 1.0 - pool_type, pool_size = 'block', 2 - S = nest.Create('aeif_cond_alpha_astro', N_S) - T = nest.Create('aeif_cond_alpha_astro', N_T) - A = nest.Create('astrocyte_lr_1994', N_A) - conn_spec = {'rule': 'tripartite_bernoulli_with_pool', - 'p_primary': p_primary, - 'p_third_if_primary': p_third_if_primary, - 'pool_type': pool_type, - 'pool_size': pool_size} - syn_specs = {'third_out': 'sic_connection'} - nest.TripartiteConnect(S, T, A, conn_spec, syn_specs) - - -.. image:: ../static/img/tripartite_pool_type.svg - :align: center - -(A) In the example of ``'random'`` pool type, each node in ``T`` can be connected with -up to two randomly selected nodes in ``A`` (given ``pool_size == 2``). (B) In -the first example of ``'block'`` pool type, let ``N_T/N_A`` = 2, -then each node in ``T`` can be connected with one node in ``A`` -(``pool_size == 1`` is required because ``N_A < N_T``), and each node in -``A`` can be connected with up to two nodes in ``T``. (C) In the second example -of ``'block'`` pool type, let ``N_A/N_T`` = 2, then each node in -``T`` can be connected with up to two nodes in ``A`` (``pool_size == 2`` is -required because ``N_A/N_T`` = 2), and each node in ``A`` can be -connected to one node in ``T``. - - -.. _synapse_spec: - -Synapse Specification ---------------------- The synapse properties can be given as just the name of the desired synapse model as a string, as a dictionary specifying synapse model @@ -460,7 +41,7 @@ as long as they are supported by the chosen connection rule. .. _scalar_params: Scalar parameters -~~~~~~~~~~~~~~~~~ +----------------- Scalar parameters must be given with the correct type. The ``weight`` for instance must be a float, while the ``receptor_type`` has to be of @@ -480,18 +61,33 @@ will be applied to all connections created in the current .. _array_params: Array parameters -~~~~~~~~~~~~~~~~ +---------------- -Array parameters can be used with the rules ``all_to_all``, -``fixed_indegree``, ``fixed_outdegree``, ``fixed_total_number`` and -``one_to_one``. The arrays can be specified as NumPy arrays or Python +Array parameters can be used with the rules ``one_to_one``, ``all_to_all``, +``fixed_total_number``, ``fixed_indegree``, and ``fixed_outdegree``. +For details on connection rules, see :ref:`connectivity_concept`. +The arrays can be specified as NumPy arrays or Python lists. As with the scalar parameters, all parameters have to be specified as arrays of the correct type. -rule: all-to-all -^^^^^^^^^^^^^^^^ +One-to-one +~~~~~~~~~~ + +For rule :ref:`one_to_one` the array must have the same length as there +are nodes in ``A`` and ``B``. -When connecting with rule ``all_to_all``, the array parameter must +.. code-block:: python + + A = nest.Create('iaf_psc_alpha', 2) + B = nest.Create('spike_recorder', 2) + conn_spec_dict = {'rule': 'one_to_one'} + syn_spec_dict = {'weight': [1.2, -3.5]} + nest.Connect(A, B, conn_spec_dict, syn_spec_dict) + +All-to-all +~~~~~~~~~~ + +When connecting with rule :ref:`all_to_all`, the array parameter must have dimension `len(B) x len(A)`. .. code-block:: python @@ -501,10 +97,24 @@ have dimension `len(B) x len(A)`. syn_spec_dict = {'weight': [[1.2, -3.5, 2.5], [0.4, -0.2, 0.7]]} nest.Connect(A, B, syn_spec=syn_spec_dict) -rule: fixed indegree -^^^^^^^^^^^^^^^^^^^^ +Random, fixed total number +~~~~~~~~~~~~~~~~~~~~~~~~~~ + +For rule :ref:`fixed_total_number`, the array has to be same the length as the +number of connections ``N``. + +.. code-block:: python -For rule ``fixed_indegree`` the array has to be a two-dimensional + A = nest.Create('iaf_psc_alpha', 3) + B = nest.Create('iaf_psc_alpha', 4) + conn_spec_dict = {'rule': 'fixed_total_number', 'N': 4} + syn_spec_dict = {'weight': [1.2, -3.5, 0.4, -0.2]} + nest.Connect(A, B, conn_spec_dict, syn_spec_dict) + +Random, fixed in-degree +~~~~~~~~~~~~~~~~~~~~~~~ + +For rule :ref:`fixed_indegree` the array has to be a two-dimensional NumPy array or Python list with shape ``(len(B), indegree)``, where :hxt_ref:`indegree` is the number of incoming connections per target neuron. This means that the rows describe the target, while the columns @@ -519,10 +129,10 @@ of the identity of the source neurons. syn_spec_dict = {'weight': [[1.2, -3.5],[0.4, -0.2],[0.6, 2.2]]} nest.Connect(A, B, conn_spec_dict, syn_spec_dict) -rule: fixed outdegree -^^^^^^^^^^^^^^^^^^^^^ +Random, fixed out-degree +~~~~~~~~~~~~~~~~~~~~~~~~ -For rule ``fixed_outdegree`` the array has to be a two-dimensional +For rule :ref:`fixed_outdegree` the array has to be a two-dimensional NumPy array or Python list with shape ``(len(A), outdegree)``, where :hxt_ref:`outdegree` is the number of outgoing connections per source neuron. This means that the rows describe the source, while the @@ -537,38 +147,10 @@ regardless of the identity of the target neuron. syn_spec_dict = {'weight': [[1.2, -3.5, 0.4], [-0.2, 0.6, 2.2]]} nest.Connect(A, B, conn_spec_dict, syn_spec_dict) -rule: fixed total number -^^^^^^^^^^^^^^^^^^^^^^^^ - -For rule ``fixed_total_number``, the array has to be same the length as the -number of connections ``N``. - -.. code-block:: python - - A = nest.Create('iaf_psc_alpha', 3) - B = nest.Create('iaf_psc_alpha', 4) - conn_spec_dict = {'rule': 'fixed_total_number', 'N': 4} - syn_spec_dict = {'weight': [1.2, -3.5, 0.4, -0.2]} - nest.Connect(A, B, conn_spec_dict, syn_spec_dict) - -rule: one-to-one -^^^^^^^^^^^^^^^^ - -For rule ``one_to_one`` the array must have the same length as there -are nodes in ``A`` and ``B``. - -.. code-block:: python - - A = nest.Create('iaf_psc_alpha', 2) - B = nest.Create('spike_recorder', 2) - conn_spec_dict = {'rule': 'one_to_one'} - syn_spec_dict = {'weight': [1.2, -3.5]} - nest.Connect(A, B, conn_spec_dict, syn_spec_dict) - .. _dist_params: Expressions as parameters -~~~~~~~~~~~~~~~~~~~~~~~~~ +------------------------- ``nest.Parameter`` objects support a flexible specification of synapse parameters through expressions. This includes parameters drawn from random @@ -633,7 +215,7 @@ For further information on the available distributions see .. _collocated_synapses: Collocated synapses -~~~~~~~~~~~~~~~~~~~ +------------------- Some modeling applications require multiple connections between the same pairs of nodes. An example of this could be a network, where each @@ -705,7 +287,7 @@ your ``CollocatedSynapses`` object: 2 Spatially-structured networks ------------------------------ +--------------------------------- Nodes in NEST can be created so that they have a position in two- or three-dimensional space. To take full advantage of the arrangement of @@ -715,7 +297,7 @@ networks ` for the full information about how to create and connect such networks. Connecting sparse matrices with array indexing ----------------------------------------------- +-------------------------------------------------- Oftentimes, you will find yourself in a situation, where you want to base your connectivity on actual data instead of rules. A common @@ -778,7 +360,7 @@ columns and :math:`m` rows. .. _receptor-types: Receptor Types --------------- +------------------- Conceptually, each connection in NEST terminates at a `receptor` on the target node. The exact meaning of such a receptor depends on the @@ -1134,11 +716,3 @@ using the dot-notation: Note that some parameters like ``source`` and ``target`` are read-only and cannot be set. The documentation of a specific synapse model will point out which parameters can be set and which are read-only. - -References ----------- - -.. [1] Djurfeldt M, Davison AP and Eppler JM (2014). Efficient generation of - connectivity in neuronal networks from simulator-independent - descriptions. Front. Neuroinform. - https://doi.org/10.3389/fninf.2014.00043 diff --git a/doc/htmldoc/tutorials/pynest_tutorial/part_1_neurons_and_simple_neural_networks.rst b/doc/htmldoc/tutorials/pynest_tutorial/part_1_neurons_and_simple_neural_networks.rst index d810e77c76..a14057979f 100644 --- a/doc/htmldoc/tutorials/pynest_tutorial/part_1_neurons_and_simple_neural_networks.rst +++ b/doc/htmldoc/tutorials/pynest_tutorial/part_1_neurons_and_simple_neural_networks.rst @@ -510,7 +510,7 @@ Connections This is an abbreviated version of the documentation for the :py:func:`.Connect` function, please see NEST's online help for the full version and -:ref:`Connection Management ` for an introduction +:ref:`Connectivity concepts ` for an introduction and examples. - ``Connect(pre, post, conn_spec=None, syn_spec=None, return_synapsecollection=False)`` diff --git a/doc/htmldoc/tutorials/pynest_tutorial/part_2_populations_of_neurons.rst b/doc/htmldoc/tutorials/pynest_tutorial/part_2_populations_of_neurons.rst index 6fc2395032..9e773fcff7 100644 --- a/doc/htmldoc/tutorials/pynest_tutorial/part_2_populations_of_neurons.rst +++ b/doc/htmldoc/tutorials/pynest_tutorial/part_2_populations_of_neurons.rst @@ -202,7 +202,7 @@ Here we have just used very simple connection schemes. Connectivity patterns requiring the specification of further parameters, such as in-degree or connection probabilities, must be defined in a dictionary containing the key ``rule`` and the key for parameters associated to the -rule. Please see :ref:`Connection management ` +rule. Please see :ref:`Connectivity concepts ` for an illustrated guide to the usage of :py:func:`.Connect`, as well as the example below. Connecting populations with random connections @@ -267,8 +267,8 @@ Note that for all connectivity rules, it is perfectly legitimate to have the same population simultaneously in the role of ``pre`` and ``post``. For more information on connecting neurons, please read the -documentation of the :py:func:`.Connect` function and consult the guide at -:ref:`Connection management `. +documentation of the :py:func:`.Connect` function and consult the guide on +:ref:`connectivity concepts `. Specifying the behaviour of devices ----------------------------------- diff --git a/doc/htmldoc/tutorials/pynest_tutorial/part_3_connecting_networks_with_synapses.rst b/doc/htmldoc/tutorials/pynest_tutorial/part_3_connecting_networks_with_synapses.rst index 93a2b2ea8d..2ccef0b9a2 100644 --- a/doc/htmldoc/tutorials/pynest_tutorial/part_3_connecting_networks_with_synapses.rst +++ b/doc/htmldoc/tutorials/pynest_tutorial/part_3_connecting_networks_with_synapses.rst @@ -119,7 +119,7 @@ parameters associated with the distribution can be set (for example nest.Connect(epop1, neuron, "all_to_all", syn_dict) Available distributions and associated parameters are described in -:ref:`Connection Management `, the most common +:ref:`parametrization `, the most common ones are: +-------------------+------------------------+ diff --git a/doc/htmldoc/whats_new/v3.7/index.rst b/doc/htmldoc/whats_new/v3.7/index.rst index 6dedc980f1..c260b7b1fc 100644 --- a/doc/htmldoc/whats_new/v3.7/index.rst +++ b/doc/htmldoc/whats_new/v3.7/index.rst @@ -29,11 +29,10 @@ For further information, see: * :doc:`/auto_examples/eprop_plasticity/index` * :doc:`/models/index_e-prop plasticity` -.. [1] Bellec G, Scherr F, Subramoney F, Hajek E, Salaj D, Legenstein R, - Maass W (2020). A solution to the learning dilemma for recurrent - networks of spiking neurons. Nature Communications, 11:3625. - https://doi.org/10.1038/s41467-020-17236-y +Connectivity concepts +--------------------- +The documentation on :ref:`connectivity_concepts` now serves as a living reference for the connection rules defined in the article "Connectivity concepts in neuronal network modeling" [2]_. Tripartite connectivity in NEST ------------------------------- @@ -55,6 +54,17 @@ See connectivity documentation: * :ref:`tripartite_connectivity` +New connection rule: ``pairwise_poisson`` +------------------------------------------ + +The number of synapses between pre- and post-synaptic neurons is drawn from a Poisson distribution. +The ``pairwise_poisson`` method is adapted from the ``pairwise bernouilli`` method. + + +See more information: + +* :ref:`pairwise_poisson` + Ignore-and-fire neuron model ---------------------------- @@ -75,24 +85,9 @@ Neuron model with integrated short-term plasticity The new ``iaf_tum_2000`` neuron model incoroporates the ``tsodyks_synapse`` directly into the neuron model. In particular, -``iaf_tum_2000`` implements short-term depression and short-term facilitation based on Tsodyks et al. [2]_. +``iaf_tum_2000`` implements short-term depression and short-term facilitation based on Tsodyks et al. [3]_. It is based on the ``iaf_psc_exp`` model. -.. [2] Tsodyks M, Uziel A, Markram H (2000). Synchrony generation in recurrent - networks with frequency-dependent synapses. Journal of Neuroscience, - 20 RC50. URL: http://infoscience.epfl.ch/record/183402 - - -New connection rule: ``pairwise_poisson`` ------------------------------------------- - -The number of synapses between pre- and post-synaptic neurons is drawn from a Poisson distribution. -The ``pairwise_poisson`` method is adapted from the ``pairwise bernouilli`` method. - - -See more information: - -* :ref:`connection_management` New parameter for compartmental model ------------------------------------- @@ -127,3 +122,17 @@ NEST requires C++17 From NEST 3.7 on, we use some C++17 features in NEST code. Therefore, NEST needs to be built with a compiler that supports C++17. Most recent C++ compilers should do so. + +References +---------- + +.. [1] Bellec G, Scherr F, Subramoney F, Hajek E, Salaj D, Legenstein R, + Maass W (2020). A solution to the learning dilemma for recurrent + networks of spiking neurons. Nature Communications, 11:3625. + https://doi.org/10.1038/s41467-020-17236-y + +.. [2] Senk J, Kriener B, Djurfeldt M, Voges N, Jiang HJ, et al. (2022) Connectivity concepts in neuronal network modeling. PLOS Computational Biology 18(9): e1010086. https://doi.org/10.1371/journal.pcbi.1010086 + +.. [3] Tsodyks M, Uziel A, Markram H (2000). Synchrony generation in recurrent + networks with frequency-dependent synapses. Journal of Neuroscience, + 20 RC50. URL: http://infoscience.epfl.ch/record/183402 diff --git a/models/multimeter.h b/models/multimeter.h index b22190c5a2..027387f093 100644 --- a/models/multimeter.h +++ b/models/multimeter.h @@ -96,8 +96,8 @@ it should record from by using the standard ``Connect`` routine. nest.Connect(mm, neurons) To learn more about possible connection patterns and additional -options when using ``Connect``, see the guide on :ref:`connection -management `. +options when using ``Connect``, see the guide on :ref:`connectivity +concepts `. The above call to ``Connect`` would fail if the neurons would not support the sampling of the values ``V_m`` and ``g_ex``. It would also diff --git a/pynest/nest/lib/hl_api_connections.py b/pynest/nest/lib/hl_api_connections.py index c6f8475c1f..a415b71727 100644 --- a/pynest/nest/lib/hl_api_connections.py +++ b/pynest/nest/lib/hl_api_connections.py @@ -204,7 +204,7 @@ def Connect(pre, post, conn_spec=None, syn_spec=None, return_synapsecollection=F See Also --------- - :ref:`connection_management` + :ref:`connectivity_concepts` """ use_connect_arrays, pre, post = _process_input_nodes(pre, post, conn_spec) @@ -374,7 +374,7 @@ def TripartiteConnect(pre, post, third, conn_spec, syn_specs=None): See Also --------- - :ref:`connection_management` + :ref:`connectivity_concepts` """ # Confirm that we got node collections