Structure-dynamics relationships in bursting neuronal networks revealed (Mäki-Marttunen et al. 2013)

 Download zip file 
Help downloading and running models
This entry includes tools for generating and analyzing network structure, and for running the neuronal network simulations on them.
1 . Mäki-Marttunen T, Acimovic J, Ruohonen K, Linne ML (2013) Structure-dynamics relationships in bursting neuronal networks revealed using a prediction framework. PLoS One 8:e69373 [PubMed]
Citations  Citation Browser
Model Information (Click on a link to find other models with that property)
Model Type: Realistic Network;
Brain Region(s)/Organism:
Cell Type(s): Neocortex L5/6 pyramidal GLU cell; Abstract Wang-Buzsaki neuron; Abstract integrate-and-fire leaky neuron;
Channel(s): I Na,p; I Na,t; I K; I K,leak; I M;
Gap Junctions:
Receptor(s): GabaA; AMPA; NMDA;
Transmitter(s): Gaba; Glutamate;
Simulation Environment: NEST; MATLAB; Python;
Model Concept(s): Bursting; Synchronization; Short-term Synaptic Plasticity; Methods; Connectivity matrix;
Implementer(s): Maki-Marttunen, Tuomo [tuomomm at];
Search NeuronDB for information about:  Neocortex L5/6 pyramidal GLU cell; GabaA; AMPA; NMDA; I Na,p; I Na,t; I K; I K,leak; I M; Gaba; Glutamate;
%function M=Lrandnetwork(N,p,pow,rotlen)
%  Creates a network, where directed loops of length rotlen are promoted.
%  Input:
%    N - number of nodes
%    p - connection probability OR a vector of length N denoting the
%        probabilities of each number inputs
%    pow - the strength of the loop promotion [0,inf]
%    rotlen - the promoted loop length
%  Output:
%    M - the connectivity matrix such that M(i,j) denotes the existence of
%        an edge from i to j
%  Tuomo Mäki-Marttunen
%  Last modified 8.1.2013

function M=Lrandnetwork(N,p,pow,rotlen)

  M = zeros(N,N);
  if nargin < 3 || isempty(pow)
    pow = 1;
  if nargin < 4 || isempty(rotlen)
    rotlen = 3;
  if numel(p)==1  
    nns = binornd(N-1,p,N,1);  
  elseif numel(p)==N
    nns = zeros(N,1);
    %p(i) gives the probability that number of in-neighbours is i-1 (i=1,...,N)
    p = p/sum(p);
    pcs = cumsum(p);
    for i=1:N
      [vain,nns(i)] = max(rand() <= pcs); %[~,nns(i)] not supported in all versions 
    nns = nns - 1;
  pinds = cell(N);
  for i=1:N
      pinds{i} = [1:i-1,i+1:N];
  nplaced = zeros(N,1);
  lastinput = 0; %this tells which node was last chosen to be an input
  for ie=1:sum(nns) %go through all the edges in a non-obvious order
    if lastinput %if some node has already been chosen as an input
        if nplaced(lastinput) < nns(lastinput) %if this node has to have more inputs
            i = lastinput; %choose that one
        else %otherwise pick by random
            w = nns - nplaced;
            w = w/sum(w);
            r = rand(1) < cumsum(w);
            i = find(r,1);
    else %otherwise pick by random
        w = nns - nplaced;
        w = w/sum(w);
        r = rand(1) < cumsum(w);
        i = find(r,1);
    pind = pinds{i};
    Npaths = nminpath(M,i,rotlen); %a matrix that tells the number of paths from i to other nodes

    % The points are given such that the highest points (>4) will be for
    % those nodes, to which there is a path from i of length rotlen-1, but no path
    % shorter than that. Choosing a such node as input will close the loop
    % of length rotlen. The second largest points (>3) is given to those
    % nodes, that are not reachable from i with a path of length rotlen-1,
    % but on the other hand not with any shorter path either. Choosing such
    % a node will not close a loop of length <= rotlen. The second lowest
    % points (>2) is given to nodes that are reachable from i with rotlen-1
    % edges, but which are also reachable by shorter paths. Choosing such a
    % node will close a loop of length < rotlen. The least points (1) are given
    % to the remaining nodes.
    points = (Npaths(end,:)&~any(Npaths(1:end-1,:),1)).*(4+Npaths(end,:)./((N-2)/(rotlen-2))^(rotlen-2)) +...
             (~Npaths(end,:)&~any(Npaths(1:end-1,:),1))*3 +...
             (Npaths(end,:)&any(Npaths(1:end-1,:),1)).*(2+Npaths(end,:)./((N-1)^(rotlen-2))) +...
    if ~isinf(pow)
      weights = points(pind).^pow;
      weights = points(pind) == max(points(pind));
    if any(isinf(weights)) %if the weight of any node is inf, the choice will be made by random between such nodes
      weights = isinf(weights);
    if all(weights==0)
      weights = weights+1;
    weights = weights/sum(weights);
    r = rand(1) < cumsum(weights');
    rind = find(r,1);
    M(pind(rind),i) = 1;
    lastinput = pind(rind);
    nplaced(i) = nplaced(i) + 1;
    pind(rind) = [];
    pinds{i} = pind;

%function nminpath returns a matrix that tells by how many paths you can
% reach nodes 1...N (horizontal) using 1...rotlen-1 (vertical) edges from
% node i
function Npaths = nminpath(M,i,rotlen) 
  N = size(M,1);
  Npaths = zeros(rotlen-1,N);
  Npaths(1,:) = M(i,:);
  for j=2:rotlen-1
    Npaths(j,:) = Npaths(j-1,:)*M;