def test_delay_doublepop():
# Settings:
t0 = 0.
dt = .001
tf = .010
verbose = False
# Create populations:
b1 = ExternalPopulation(50)
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.001, update_method='exact')
i2 = InternalPopulation(v_min=0, v_max=.02, dv=.001, update_method='exact')
# Create connections:
b1_i1 = Connection(b1, i1, 2, weights=[.005], probs=[1.])
i1_i2 = Connection(i1, i2, 20, weights=[.005], probs=[1.], delay=2 * dt)
# Create and run simulation:
simulation = Simulation([b1, i1, i2], [b1_i1, i1_i2], verbose=verbose)
simulation.run(dt=dt, tf=tf, t0=t0)
true_ans = np.array([
0, 0.0, 0.0, 0.0, 1.9089656152757652e-13, 1.9787511418980406e-10,
9.5007650186649266e-09, 1.3334881090883857e-07, 1.0103767575651715e-06,
5.3604521936092067e-06, 2.2383604753409621e-05
])
np.testing.assert_almost_equal(i2.firing_rate_record, true_ans, 12)
def get_matrices():
dv = .001
nsyn_bg = 1
bgfr = 200
we = .1
wi = -.1
nsyn_00, nsyn_01, nsyn_10, nsyn_11 = 5, 5, 2, 20
# Components:
b0 = ExternalPopulation(bgfr, record=True)
i0 = InternalPopulation(tau_m=.05,
v_min=0,
v_max=1,
dv=dv,
update_method='gmres')
i1 = InternalPopulation(tau_m=.05,
v_min=0,
v_max=1,
dv=dv,
update_method='gmres')
b0_i0 = Connection(b0, i0, nsyn_bg, weights=we, delays=0.0)
b0_i1 = Connection(b0, i1, nsyn_bg, weights=we, delays=0.0)
i0_i0 = Connection(i0, i0, nsyn_00, weights=we, delays=0.0)
i0_i1 = Connection(i0, i1, nsyn_01, weights=we, delays=0.0)
i1_i0 = Connection(i1, i0, nsyn_10, weights=wi, delays=0.0)
i1_i1 = Connection(i1, i1, nsyn_11, weights=wi, delays=0.0)
L = get_leak_matrix(i1)
Se, te = get_connection_flux_matrices(b0_i0)
Si, _ = get_connection_flux_matrices(i1_i0)
return L, Se, Si, te
def test_singlepop():
# Settings:
t0 = 0.
dt = .001
dv = .001
v_min = -.01
v_max = .02
tf = .2
verbose = False
# Create simulation:
b1 = ExternalPopulation(50)
b2 = ExternalPopulation(50)
i1 = InternalPopulation(v_min=v_min,
v_max=v_max,
dv=dv,
update_method='exact')
b1_i1 = Connection(b1, i1, 1, weights=[.005], probs=[1.])
b2_i1 = Connection(b2, i1, 1, weights=[.005], probs=[1.])
simulation = Simulation([b1, b2, i1], [b1_i1, b2_i1], verbose=verbose)
simulation.run(dt=dt, tf=tf, t0=t0)
np.testing.assert_almost_equal(i1.t_record[-1], .2, 15)
np.testing.assert_almost_equal(i1.firing_rate_record[-1],
5.3550005434746355, 12)
assert i1.n_bins == (v_max - v_min) / dv
assert i1.n_edges - 1 == i1.n_bins
assert len(simulation.population_list) == 3
i1.plot_probability_distribution()
def test_singlepop():
# Settings:
t0 = 0.
dt = .001
dv = .001
v_min = -.01
v_max = .02
tf = .2
verbose = False
# Create simulation:
b1 = ExternalPopulation(50)
b2 = ExternalPopulation(50)
i1 = InternalPopulation(v_min=v_min, v_max=v_max, dv=dv, update_method='exact')
b1_i1 = Connection(b1, i1, 1, weights=[.005], probs=[1.])
b2_i1 = Connection(b2, i1, 1, weights=[.005], probs=[1.])
simulation = Simulation([b1, b2, i1], [b1_i1, b2_i1], verbose=verbose)
simulation.run(dt=dt, tf=tf, t0=t0)
np.testing.assert_almost_equal(i1.t_record[-1], .2, 15)
np.testing.assert_almost_equal(i1.firing_rate_record[-1], 5.3550005434746355, 12)
assert i1.n_bins == (v_max - v_min)/dv
assert i1.n_edges - 1 == i1.n_bins
assert len(simulation.population_list) == 3
i1.plot_probability_distribution()
def test_network_df():
p1 = ExternalPopulation(100, record=True)
p2 = ExternalPopulation(200, record=False)
p3 = InternalPopulation(v_min=0, v_max=.02, metadata={'X': 0})
p4 = InternalPopulation(v_min=0, v_max=.01, metadata={'X': 0})
n1 = Network(population_list=[p1, p2, p3, p4])
print n1.to_df()
def test_restart_interal():
# Run part-way and serialize:
b1 = ExternalPopulation('100', record=True)
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.001)
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=0.0)
simulation = Network([b1, i1], [b1_i1])
simulation.run(dt=.001, tf=.01, t0=0)
i1_str = i1.to_json()
b1_str = b1.to_json()
# Rehydrate and continue run:
b2 = ExternalPopulation(**json.loads(b1_str))
i2 = InternalPopulation(**json.loads(i1_str))
simulation2 = Network([b2, i2], [Connection(b2, i2, 1, weights=.005, delays=0.0)])
simulation2.run(dt=.001, tf=.02, t0=.01)
# Run straight through, for comparison:
b3 = ExternalPopulation('100', record=True)
i3 = InternalPopulation(v_min=0, v_max=.02, dv=.001)
simulation3 = Network([b3, i3], [Connection(b3, i3, 1, weights=.005, delays=0.0)])
simulation3.run(dt=.001, tf=.02, t0=0)
# Test:
for y1, y2 in zip(i1.firing_rate_record, i3.firing_rate_record):
np.testing.assert_almost_equal(y1, y2, 8)
b3.to_json(StringIO.StringIO())
i3.to_json(StringIO.StringIO())
b1_i1.to_json(StringIO.StringIO())
def test_simulation_copy():
b1 = ExternalPopulation(100)
i1 = InternalPopulation(v_min=0, v_max=.02)
b1_i1 = Connection(b1, i1, 2, weights=.005)
o1 = Network([b1, i1], [b1_i1])
o2 = o1.copy()
compare(o1, o2)
def get_simulation(dv=.001,
verbose=False,
update_method='approx',
approx_order=None,
tol=1e-8):
import scipy.stats as sps
# Create simulation:
b1 = ExternalPopulation(100)
i1 = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
b1_i1 = Connection(b1,
i1,
1,
delay=0.0,
distribution=sps.expon,
N=201,
scale=.005)
simulation = Simulation([b1, i1], [b1_i1], verbose=verbose)
return simulation
def get_singlepop_benchmark_network(scale=2):
from dipde.internals.internalpopulation import InternalPopulation
from dipde.internals.externalpopulation import ExternalPopulation
from dipde.internals.network import Network
from dipde.internals.connection import Connection as Connection
# Settings:
dv = .0001
update_method = 'approx'
approx_order = None
tol = 1e-14
# Run simulation:
b_list = []
i_list = []
conn_list = []
for _ in range(scale):
b = ExternalPopulation(100, record=True)
i = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
c = Connection(b, i, 1, weights=.005)
b_list += [b]
i_list += [i]
conn_list += [c]
return Network(b_list + i_list, conn_list)
def singlepop(steady_state, tau_m=.02, p0=((0.,),(1.,)), weights={'distribution':'delta', 'loc':.005}, bgfr=100, network_update_callback=lambda s: None, update_method='approx', simulation_configuration=None, tol=None):
# Settings:
t0 = 0.
dt = .001
dv = .001
v_min = -.01
v_max = .02
tf = .1
# Create simulation:
b1 = ExternalPopulation(bgfr)
i1 = InternalPopulation(v_min=v_min, tau_m=tau_m, v_max=v_max, dv=dv, update_method=update_method, p0=p0, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=weights)
network = Network([b1, i1], [b1_i1], update_callback=network_update_callback)
if simulation_configuration is None:
simulation_configuration = SimulationConfiguration(dt, tf, t0=t0)
simulation = Simulation(network=network, simulation_configuration=simulation_configuration)
simulation.run()
b1.plot()
i1.plot_probability_distribution()
i1.plot()
assert i1.n_edges == i1.n_bins+1
# Test steady-state:
np.testing.assert_almost_equal(i1.get_firing_rate(.05), steady_state, 12)
def test_access_matrices():
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.0001)
c1 = Connection(None, i1, 1, weights=.005)
leak_matrix = get_leak_matrix(i1)
synaptic_matrix, threshold_vector = get_connection_flux_matrices(c1)
assert leak_matrix.shape == synaptic_matrix.shape
assert synaptic_matrix.shape[0] == threshold_vector.shape[0]
def get_simulation(dt=.001, dv=.001, tf=.2, verbose=False, update_method='exact', approx_order=None, tol=1e-8):
# Create simulation:
b1 = ExternalPopulation('100')
i1 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=[.005], probs=[1.], delay=0.0)
simulation = Simulation([b1, i1], [b1_i1], dt=dt, tf=tf, verbose=verbose)
return simulation
def get_simulation(dv=.001, update_method='exact', approx_order=None, tol=1e-8):
# Create simulation:
b1 = ExternalPopulation('100+50*abs(sin(40*t))')
i1 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=0.0)
simulation = Network([b1, i1], [b1_i1])
return simulation
def get_network(dv=.001, verbose=False, update_method='approx', approx_order=1, tol=1e-14):
# Create network:
b1 = ExternalPopulation('100')
i1 = InternalPopulation(v_min=-.02, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=([.005, .01],[.5,.5]))
b1_i1_2 = Connection(b1, i1, 1, weights=-.005, delays=sps.uniform(0,.01))
network = Network([b1, i1], [b1_i1, b1_i1_2])
return network
def test_delay_distribution():
# Settings:
t0 = 0.
dt = .001
tf = .1
# Create populations:
b1 = ExternalPopulation('100*Heaviside(t)')
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.001, update_method='exact')
# Create connections:
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=((0,.05),(.5,.5)))
# Create and run simulation:
simulation = Network([b1, i1], [b1_i1])
simulation.run(dt=dt, tf=tf, t0=t0)
true_ans = np.array([0.38560647739319964, 5.229266329159536])
np.testing.assert_almost_equal(np.array(i1.get_firing_rate([.04, .09])), true_ans, 8)
def get_multipop_model():
# Settings:
dv = .001
update_method = 'approx'
approx_order = None
tol = 1e-14
# Create simulation:
b1 = ExternalPopulation(100)
b2 = ExternalPopulation(50)
i1 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
i2 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005)
i1_i2 = Connection(i1, i2, 20, weights=.005, delays=.001)
b2_i2 = Connection(b2, i2, 2, weights=.005, delays=.002)
simulation = Network([b1, b2, i1, i2], [b1_i1, i1_i2, b2_i2])
simulation_dict = simulation.to_dict()
return simulation_dict
def singlepop(steady_state, tau_m=.02, p0=((0.,),(1.,)), weights={'distribution':'delta', 'loc':.005}, bgfr=100, network_update_callback=lambda s: None, update_method='approx', simulation_configuration=None, tol=None, checkpoint_callback=None, nsyn=1):
# Settings:
t0 = 0.
dt = .001
dv = .001
v_min = -.01
v_max = .02
tf = .1
# Create simulation:
b1 = ExternalPopulation(bgfr)
i1 = InternalPopulation(v_min=v_min, tau_m=tau_m, v_max=v_max, dv=dv, update_method=update_method, p0=p0, tol=tol)
b1_i1 = Connection(b1, i1, nsyn, weights=weights)
network = Network([b1, i1], [b1_i1], update_callback=network_update_callback)
if simulation_configuration is None:
simulation_configuration = SimulationConfiguration(dt, tf, t0=t0)
simulation = Simulation(network=network, simulation_configuration=simulation_configuration, checkpoint_callback=checkpoint_callback)
simulation.run()
b1.plot()
i1.plot_probability_distribution()
i1.plot()
assert i1.n_edges == i1.n_bins+1
# Test steady-state:
np.testing.assert_almost_equal(i1.get_firing_rate(.05), steady_state, 12)
def get_network(dv=.001, update_method='exact', tol=1e-14):
# Create simulation:
b1 = ExternalPopulation('100', record=True)
i1 = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=0.0)
network = Network([b1, i1], [b1_i1])
return network
def test_delay_singlepop():
# Settings:
t0 = 0.
dt = .001
tf = .005
verbose = False
# Create simulation:
b1 = ExternalPopulation('Heaviside(t)*100')
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.001, update_method='exact')
b1_i1 = Connection(b1, i1, 1, weights=[.005], probs=[1.], delay=2*dt)
simulation = Simulation([b1, i1], [b1_i1], verbose=verbose)
simulation.run(dt=dt, tf=tf, t0=t0)
true_ans = np.array([0, 0.0, 0.0, 0.00066516669656511084, 0.025842290308637855, 0.08117342489138904])
np.testing.assert_almost_equal(i1.firing_rate_record, true_ans, 12)
def test_get_J():
# Settings:
bgfr=100
update_method='approx'
weights={'distribution':'delta', 'loc':.005}
p0=((0.,),(1.,))
tau_m=.02
dv = .001
v_min = -.01
v_max = .02
# Create simulation:
b1 = ExternalPopulation(bgfr)
i1 = InternalPopulation(v_min=v_min, tau_m=tau_m, v_max=v_max, dv=dv, update_method=update_method, p0=p0)
b1_i1 = Connection(b1, i1, 1, weights=weights)
network = Network([b1, i1], [b1_i1])
network.get_total_flux_matrix(i1,.001)
def get_simulation(dv=.001,
verbose=False,
update_method='exact',
approx_order=None,
tol=1e-8):
# Create simulation:
f = RequestFiringRateFunction(5555)
b1 = ExternalPopulation(f, record=True, name='b1')
i1 = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005, delay=0.0)
simulation = Network([b1, i1], [b1_i1], verbose=verbose)
return simulation
def test_delay_singlepop():
# Settings:
t0 = 0.
dt = .001
tf = .005
# Create simulation:
b1 = ExternalPopulation('Heaviside(t)*100')
i1 = InternalPopulation(v_min=0, v_max=.02, dv=.001, update_method='exact')
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=2*dt, delay_queue=[0,0,50])
# # DEBUG:
# b1_i1 = Connection(b1, i1, 1, weights=.005, delays=((0,.001, .002),(0,0,1.)), delay_queue=[0,0,50])
simulation = Network([b1, i1], [b1_i1])
simulation.run(dt=dt, tf=tf, t0=t0)
true_ans = np.array([0, 0.0, 0.0, 0.00066516669656511084, 0.025842290308637855, 0.08117342489138904])
np.testing.assert_almost_equal(i1.firing_rate_record, true_ans, 12)
def get_simulation(dv=.001,
update_method='approx',
approx_order=None,
tol=1e-8):
import scipy.stats as sps
# Create simulation:
b1 = ExternalPopulation(100)
i1 = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
b1_i1 = Connection(b1,
i1,
1,
delays=0.0,
weights=(sps.expon(0, .005), 201))
simulation = Network([b1, i1], [b1_i1])
return simulation
def get_simulation(dv=.001, update_method='approx', tol=1e-8):
import scipy.stats as sps
# Create simulation:
b1 = ExternalPopulation(50)
b2 = ExternalPopulation(1000)
i1 = InternalPopulation(v_min=-.04,
v_max=.02,
dv=dv,
update_method=update_method,
tol=tol)
b1_i1 = Connection(b1,
i1,
1,
delays=0.0,
weights=(sps.expon(0, .00196), 301))
b2_i1 = Connection(b2,
i1,
1,
delays=0.0,
weights=(sps.expon(0, .001), 301))
simulation = Network([b1, b2, i1], [b1_i1, b2_i1])
return simulation
t0 = 0.
dt = 0.0001
dv = 0.1
tf = 1. #.1 #simulation duration.
update_method = 'approx'
approx_order = 1
tol = 1e-14
verbose = False
# Create simulation:
b1 = ExternalPopulation(p_rate, record=True)
i1 = InternalPopulation(tau_m=t_m * 1e-3,
v_min=-0.02,
v_max=u_th * 1e-3,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol,
record=True,
curr_firing_rate=0.0,
norm='inf')
i2 = InternalPopulation(tau_m=t_m * 1e-3,
v_min=-0.02,
v_max=u_th * 1e-3,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol,
record=True,
curr_firing_rate=0.0,
norm='inf')
def test_internalpopulation_df():
i1 = InternalPopulation(v_min=0, v_max=.02)
i2 = InternalPopulation(**dict_from_df(i1.to_df()))
compare_dicts(i1.to_dict(), i2.to_dict())
from dipde.internals.internalpopulation import InternalPopulation from dipde.internals.connection import Connection from dipde.interfaces.access_matrices import get_leak_matrix, get_connection_flux_matrices import numpy as np import numpy.linalg as npla import logging logging.disable(logging.CRITICAL) # Components: i1 = InternalPopulation(tau_m=.02, v_min=0, v_max=.02, dv=.001) c1 = Connection(None, i1, 1, weights=.005) # Get matrices: leak_matrix = get_leak_matrix(i1) synaptic_matrix, threshold_vector = get_connection_flux_matrices(c1) A = leak_matrix + 100 * synaptic_matrix A[0, :] = 1 b = np.zeros(A.shape[0]) b[0] = 1 # Solve for steady state: p_star = npla.solve(A, b) # Steady state firing rate print np.dot(p_star, 100 * threshold_vector) # A2 = leak_matrix + 100./(1-np.dot(p_star, threshold_vector))*synaptic_matrix # w, vl = npla.eig(A2) # # # print w[np.argmin(np.abs(w))]
def __create_internal_pop(self, params):
# TODO: use getter methods directly in case arguments are not stored in dynamics params
# pop = InternalPopulation(**params.dynamics_params)
pop = InternalPopulation(**params.model_params)
return pop
def get_infinitesimal_perturbation(t0, sigma, amplitude):
rv = sps.norm(t0, sigma)
return lambda t: rv.pdf(t)*sigma*np.sqrt(2*np.pi)*amplitude
dv = .0001
nsyn_bg = 1
bgfr = 600
weight = .03
nsyn_recc = 30 # 16
# Components:
b1 = ExternalPopulation(bgfr, record=True)
i1 = InternalPopulation(tau_m=.05, v_min=0, v_max=1, dv=dv, update_method = 'gmres')
b1_i1 = Connection(b1, i1, nsyn_bg, weights=weight, delays=0.0)
i1_i1 = Connection(i1, i1, nsyn_recc, weights=weight, delays=0.0)
# Get matrices:
leak_matrix = get_leak_matrix(i1, sparse=True)
# leak_matrix = spsp.csr_matrix(leak_matrix.shape)
synaptic_matrix, threshold_vector = get_connection_flux_matrices(b1_i1, sparse=True)
def f(ss_fr_guess):
A = leak_matrix + (nsyn_bg*bgfr+nsyn_recc*ss_fr_guess)*synaptic_matrix
def test_internalpopulation_df():
i1 = InternalPopulation(v_min=0, v_max=0.02)
i2 = InternalPopulation(**dict_from_df(i1.to_df()))
compare_dicts(i1.to_dict(), i2.to_dict())
return np.array([f0_new, f1_new])
# Compute steady state:
f0_ss, f1_ss = sopt.fixed_point(steady_state_function,
np.array([14, 9]),
args=(bgfr, nsyn_bg, nsyn_00, nsyn_01, nsyn_10,
nsyn_11, delay))
# Compute initial guesses for eigenvector and eigenvalue:
# # Components:
b1 = ExternalPopulation(bgfr, record=True)
i1 = InternalPopulation(tau_m=.05,
v_min=0,
v_max=1,
dv=dv,
update_method='gmres')
b1_i1 = Connection(b1, i1, nsyn_bg, weights=we, delays=0.0)
i1_i1 = Connection(i1, i1, 0, weights=wi, delays=0.0)
def cheb(N):
x = np.cos(np.pi * np.arange(N + 1) / N)
c = np.array([2] + [1] *
(N - 1) + [2]) * np.array([(-1)**ii for ii in range(N + 1)])
X = npm.repmat(x, 1, N + 1).reshape(N + 1, N + 1).T
dX = X - X.T
D = (np.outer(c, 1. / c)) / (dX + (np.eye(N + 1))
) # % off-diagonal entries
return D - np.diag(np.sum(
def build(self):
params = self._nodes[0].dynamics_params
self._dipde_obj = InternalPopulation(**params)
def test_internalpopulation_copy():
i1 = InternalPopulation(v_min=0, v_max=0.02)
i2 = i1.copy()
compare(i1, i2)
string, a floating point or integer specification will also work). This external
population is connected to an Internal population (modeled as a population density pde)
via a delta-distributed synaptic weight distribution, with 5 mV strength. The in-degree
(nsyn) of this Connection is set to 1 for this example. In general, this serves as a
multiplier of the input firing rate of the source population. The internal population
has a linearly binned voltage domain from v_min to v_max. No negative bins (i.e. v_min < 0)
are required here, because no negative synaptic inputs ('weights' in the Connection object)
are defined.
"""
# Create simulation
externalPopFreq = '50'
b1 = ExternalPopulation(externalPopFreq, record=True)
i1 = InternalPopulation(v_min=0,
v_max=.02,
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=[.005], probs=[1.], delay=0.0)
simulation = Simulation([b1, i1], [b1_i1], verbose=verbose)
# Run simulation
simulation.run(dt=dt, tf=tf, t0=t0)
# Visualize results
i1 = simulation.population_list[1]
plt.figure(figsize=(3, 3))
plt.plot(i1.t_record, i1.firing_rate_record)
plt.xlim([0, tf])
plt.ylim(ymin=0)
plt.xlabel('Time (s)')
}
# Simulation settings:
t0 = 0.
dt = .0002
tf = .1
verbose = True
save = False
# Create populations:
background_population_dict = {}
internal_population_dict = {}
for layer, celltype in itertools.product([23, 4, 5, 6], ['e', 'i']):
background_population_dict[layer, celltype] = ExternalPopulation(
'Heaviside(t)*%s' % background_firing_rate, record=False)
internal_population_dict[layer, celltype] = InternalPopulation(
**internal_population_settings)
# Create background connections:
connection_list = []
for layer, celltype in itertools.product([23, 4, 5, 6], ['e', 'i']):
source_population = background_population_dict[layer, celltype]
target_population = internal_population_dict[layer, celltype]
if celltype == 'e':
background_delay = .005
else:
background_delay = 0.
curr_connection = Connection(source_population,
target_population,
nsyn_background[layer, celltype],
weights=[conn_weights['e']],
probs=[1.],
# import matplotlib
# matplotlib.use('Qt4Agg')
# import matplotlib.pyplot as plt
from dipde.internals.internalpopulation import InternalPopulation
from dipde.internals.externalpopulation import ExternalPopulation
from dipde.internals.network import Network
from dipde.internals.connection import Connection as Connection
from dipde.visualization import visualize
dv = .0001
update_method = 'approx'
approx_order = 1
tol = 1e-14
b1 = ExternalPopulation('100', record=True)
i1 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
i2 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
b1_i1 = Connection(b1, i1, 1, weights=.005, delays=0.0)
b1_i2 = Connection(b1, i2, 2, weights=.005, delays=0.0)
network = Network([b1, i1, i2], [b1_i1, b1_i2])
network.run(dt=.0001, tf=.1, t0=0)
print i1.get_firing_rate(.1)
visualize(network, show=True)
print network.to_dict()
