def test_simulation_copy():
b1 = ExternalPopulation(100)
i1 = InternalPopulation(v_min=0, v_max=0.02)
b1_i1 = Connection(b1, i1, 2, weights=0.005)
o1 = Network([b1, i1], [b1_i1])
o2 = o1.copy()
compare(o1, o2)
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 test_network_df():
p1 = ExternalPopulation(100, record=True)
p2 = ExternalPopulation(200, record=False)
p3 = InternalPopulation(v_min=0, v_max=0.02, metadata={"X": 0})
p4 = InternalPopulation(v_min=0, v_max=0.01, metadata={"X": 0})
n1 = Network(population_list=[p1, p2, p3, p4])
print n1.to_df()
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 get_leak_matrix(internal_population, sparse=False):
internal_population_copy = internal_population.copy()
network = Network([internal_population_copy], [])
network.dt = 1.
network.t0 = 1.
network.ti = 1.
internal_population_copy.initialize()
if sparse == False:
return internal_population_copy.leak_flux_matrix_dict['dense'].copy()
else:
return spsp.csc_matrix(internal_population_copy.leak_flux_matrix_dict['dense'])
def test_general_interface():
# Settings:
t0 = 0.
dt = .001
tf = .01
# Run simulation:
b1 = ODE(lambda y, t:(100-t)/.1)
i1 = PopulationInterface()
b1_i1 = Connection(b1, i1, 1, weights=.005)
network = Network([b1, i1], [b1_i1])
network.run(dt, tf=tf, t0=t0)
np.testing.assert_almost_equal(b1.curr_firing_rate, 9.99949999997, 10)
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 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 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_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 get_connection_flux_matrices(connection, sparse=False):
target_population_copy = connection.target.copy()
network = Network([target_population_copy], [])
network.dt = 1.
network.t0 = 1.
network.ti = 1.
target_population_copy.initialize()
conn_dist = ConnectionDistribution(target_population_copy.edges, connection.weights, connection.probs)
conn_dist.initialize()
if sparse == False:
flux_matrix = conn_dist.flux_matrix_dict['dense'].copy()
else:
flux_matrix = spsp.csc_matrix(conn_dist.flux_matrix_dict['dense'])
flux_vector = conn_dist.threshold_flux_vector.copy()
return flux_matrix, flux_vector
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 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 test_general_interface():
# Settings:
t0 = 0.
dt = .001
tf = .01
# Run simulation:
b1 = ODE(lambda y, t:(100-t)/.1)
i1 = PopulationInterface()
b1_i1 = Connection(b1, i1, 1, weights=.005)
network = Network([b1, i1], [b1_i1])
network.run(dt, tf=tf, t0=t0)
# Tests:
final_firing_rate = 9.99949999997
np.testing.assert_almost_equal(b1.curr_firing_rate, final_firing_rate, 10)
np.testing.assert_almost_equal(i1.source_firing_rate_dict[0], final_firing_rate, 10)
assert len(i1.source_connection_list) == 1
assert i1.source_connection_list[0] == b1_i1
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 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_doublepop():
# Settings:
t0 = 0.
dt = .001
tf = .010
# 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)
i1_i2 = Connection(i1, i2, 20, weights=.005, delays=2*dt)
# Create and run simulation:
simulation = Network([b1, i1, i2], [b1_i1, i1_i2])
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 test_general_interface():
# Settings:
t0 = 0.
dt = .001
tf = .01
# Run simulation:
b1 = ODE(lambda y, t: (100 - t) / .1)
i1 = PopulationInterface()
b1_i1 = Connection(b1, i1, 1, weights=.005)
network = Network([b1, i1], [b1_i1])
network.run(dt, tf=tf, t0=t0)
# Tests:
final_firing_rate = 9.99949999997
np.testing.assert_almost_equal(b1.curr_firing_rate, final_firing_rate, 10)
np.testing.assert_almost_equal(i1.source_firing_rate_dict[0],
final_firing_rate, 10)
assert len(i1.source_connection_list) == 1
assert i1.source_connection_list[0] == b1_i1
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 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
def run(simulation_dict, run_dict, result_dict, rank=None):
t0 = run_dict['t0']
dt = run_dict['dt']
tf = run_dict['tf']
number_of_processes = run_dict.get('number_of_processes', 1)
simulation = Network(**simulation_dict)
if rank is None:
simulation.run(dt=dt, tf=tf, t0=t0)
else:
address_config_dict = {}
rank_address_function = lambda rank:"ipc://%s" % (5559+rank)
for ii in range(number_of_processes):
address_config_dict[ii] = rank_address_function(ii)
simulation.run(dt=dt, tf=tf, t0=t0, synchronization_harness=SynchronizationHarness(rank, address_config_dict, number_of_processes))
result_dict[rank] = {}
for p in simulation.population_list:
result_dict[rank][p.gid] = p.firing_rate_record
# 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()
result.append((u,v,d))
G2 = nx.MultiDiGraph(result)
for n in G2.nodes_iter():
G2.node[n] = G.node[n]
if full == True:
for ii in range(G.number_of_nodes()):
if not ii in G2:
G2.add_node(ii, G.node[n])
return G2
if __name__ == "__main__":
from dipde.examples.cortical_column import get_network, example
from dipde.internals.network import Network
network = get_network()
G = to_graph(network)
D = to_dict(G)
round_trip_network = Network(**D)
example(show=True, network=round_trip_network)
# Run simulation:
b1 = ExternalPopulation(100)
b2 = ExternalPopulation(100)
b3 = ExternalPopulation(100)
b4 = ExternalPopulation(100)
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)
i3 = InternalPopulation(v_min=0, v_max=.02, dv=dv, update_method=update_method, approx_order=approx_order, tol=tol)
i4 = 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)
b2_i2 = Connection(b2, i2, 1, weights=.005)
b3_i3 = Connection(b3, i3, 1, weights=.005)
b4_i4 = Connection(b4, i4, 1, weights=.005)
network = Network([b1, b2, b3, b4, i1, i2, i3, i4], [b1_i1, b2_i2, b3_i3, b4_i4])
address_config_dict = {}
rank_address_function = lambda rank:"ipc://%s" % (5559+rank)
for ii in range(number_of_processes):
address_config_dict[ii] = rank_address_function(ii)
run_dict = {'t0':t0,
'dt':dt,
'tf':tf,
'synchronization_harness':SynchronizationHarness(rank, address_config_dict, number_of_processes)}
t0 = time.time()
network.run(**run_dict)
print time.time() - t0
# i_tmp.initialize()
#
#
b1 = ExternalPopulation(bgfr, record=False)
i1 = 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', p0=(i_tmp.edges.tolist(), p0), initial_firing_rate=f0)
b1_i1 = Connection(b1, i1, nsyn_bg, weights=weight, delays=0.0)
i1_i1 = Connection(i1, i1, nsyn_recc, weights=weight, delays=0.0)
#
# be = ExternalPopulation(get_infinitesimal_perturbation(.1,.0005,.001), record=False)
# be_i1 = Connection(be, i1, 1, weights=weight, delays=0.0)
#
#
def chirp_fcn(n):
print n.t, ss_fr, n.population_list[1].curr_firing_rate
network = Network([b1, i1], [b1_i1, i1_i1], update_callback=chirp_fcn)
network.run(tf=5, dt=.0001)
i1.plot()
plt.show()
# def chirp(n):
# print n.t
#
# network = Network([b1, i1], [b1_i1, i1_i1], update_callback=chirp)
# network.run(tf=5, dt=.0001)
#
# ss_fr = i1.firing_rate_record[-1]
#
# # print ss_fr
# i1.plot()
dv=dv,
update_method=update_method,
approx_order=approx_order,
tol=tol)
i4 = 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)
b2_i2 = Connection(b2, i2, 1, weights=.005)
b3_i3 = Connection(b3, i3, 1, weights=.005)
b4_i4 = Connection(b4, i4, 1, weights=.005)
network = Network([b1, b2, b3, b4, i1, i2, i3, i4],
[b1_i1, b2_i2, b3_i3, b4_i4])
run_dict = {
't0':
t0,
'dt':
dt,
'tf':
tf,
'distributed_configuration':
MongoDistributedConfiguration(rank,
number_of_processes=number_of_processes)
}
import re
from dipde.internals.network import Network
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()
def get_network(dv=.0001):
nsyn_background = {
(23, 'e'): 1600,
(23, 'i'): 1500,
(4, 'e'): 2100,
(4, 'i'): 1900,
(5, 'e'): 2000,
(5, 'i'): 1900,
(6, 'e'): 2900,
(6, 'i'): 2100
}
background_firing_rate = 8
background_delay = {'e': 0.005, 'i': 0.0}
internal_population_sizes = {
(23, 'e'): 20683,
(23, 'i'): 5834,
(4, 'e'): 21915,
(4, 'i'): 5479,
(5, 'e'): 4850,
(5, 'i'): 1065,
(6, 'e'): 14395,
(6, 'i'): 2948
}
connection_probabilities = {
((23, 'e'), (23, 'e')): .101,
((23, 'e'), (23, 'i')): .135,
((23, 'e'), (4, 'e')): .008,
((23, 'e'), (4, 'i')): .069,
((23, 'e'), (5, 'e')): .100,
((23, 'e'), (5, 'i')): .055,
((23, 'e'), (6, 'e')): .016,
((23, 'e'), (6, 'i')): .036,
((23, 'i'), (23, 'e')): .169,
((23, 'i'), (23, 'i')): .137,
((23, 'i'), (4, 'e')): .006,
((23, 'i'), (4, 'i')): .003,
((23, 'i'), (5, 'e')): .062,
((23, 'i'), (5, 'i')): .027,
((23, 'i'), (6, 'e')): .007,
((23, 'i'), (6, 'i')): .001,
((4, 'e'), (23, 'e')): .088,
((4, 'e'), (23, 'i')): .032,
((4, 'e'), (4, 'e')): .050,
((4, 'e'), (4, 'i')): .079,
((4, 'e'), (5, 'e')): .051,
((4, 'e'), (5, 'i')): .026,
((4, 'e'), (6, 'e')): .021,
((4, 'e'), (6, 'i')): .003,
((4, 'i'), (23, 'e')): .082,
((4, 'i'), (23, 'i')): .052,
((4, 'i'), (4, 'e')): .135,
((4, 'i'), (4, 'i')): .160,
((4, 'i'), (5, 'e')): .006,
((4, 'i'), (5, 'i')): .002,
((4, 'i'), (6, 'e')): .017,
((4, 'i'), (6, 'i')): .001,
((5, 'e'), (23, 'e')): .032,
((5, 'e'), (23, 'i')): .075,
((5, 'e'), (4, 'e')): .007,
((5, 'e'), (4, 'i')): .003,
((5, 'e'), (5, 'e')): .083,
((5, 'e'), (5, 'i')): .060,
((5, 'e'), (6, 'e')): .057,
((5, 'e'), (6, 'i')): .028,
((5, 'i'), (23, 'e')): 0,
((5, 'i'), (23, 'i')): 0,
((5, 'i'), (4, 'e')): .0003,
((5, 'i'), (4, 'i')): 0,
((5, 'i'), (5, 'e')): .373,
((5, 'i'), (5, 'i')): .316,
((5, 'i'), (6, 'e')): .020,
((5, 'i'), (6, 'i')): .008,
((6, 'e'), (23, 'e')): .008,
((6, 'e'), (23, 'i')): .004,
((6, 'e'), (4, 'e')): .045,
((6, 'e'), (4, 'i')): .106,
((6, 'e'), (5, 'e')): .020,
((6, 'e'), (5, 'i')): .009,
((6, 'e'), (6, 'e')): .040,
((6, 'e'), (6, 'i')): .066,
((6, 'i'), (23, 'e')): 0,
((6, 'i'), (23, 'i')): 0,
((6, 'i'), (4, 'e')): 0,
((6, 'i'), (4, 'i')): 0,
((6, 'i'), (5, 'e')): 0,
((6, 'i'), (5, 'i')): 0,
((6, 'i'), (6, 'e')): .225,
((6, 'i'), (6, 'i')): .144
}
conn_weights = {'e': .175 * 1e-3, 'i': -.7 * 1e-3}
position_dict = {
(23, 'e'): (0, 0, 3),
(23, 'i'): (0, 1, 3),
(4, 'e'): (0, 0, 2),
(4, 'i'): (0, 1, 2),
(5, 'e'): (0, 0, 1),
(5, 'i'): (0, 1, 1),
(6, 'e'): (0, 0, 0),
(6, 'i'): (0, 1, 0)
}
internal_population_settings = {
'v_min': -.03,
'v_max': .015,
'dv': dv,
'update_method': 'gmres',
'tau_m': .01,
'tol': 1e-7,
'record': True
}
# 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,
metadata={
'layer': layer,
'celltype': celltype
})
curr_population_settings = copy.copy(internal_population_settings)
x_pos, y_pos, z_pos = position_dict[layer, celltype]
metadata = {
'layer': layer,
'celltype': celltype,
'x': x_pos,
'y': y_pos,
'z': z_pos,
}
curr_population_settings.update({'metadata': metadata})
internal_population_dict[layer, celltype] = InternalPopulation(
**curr_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'],
delays=background_delay)
connection_list.append(curr_connection)
# Create recurrent connections:
for source_layer, source_celltype in itertools.product([23, 4, 5, 6],
['e', 'i']):
for target_layer, target_celltype in itertools.product([23, 4, 5, 6],
['e', 'i']):
source_population = internal_population_dict[source_layer,
source_celltype]
target_population = internal_population_dict[target_layer,
target_celltype]
nsyn = connection_probabilities[
(source_layer, source_celltype),
(target_layer,
target_celltype)] * internal_population_sizes[source_layer,
source_celltype]
weight = conn_weights[source_celltype]
curr_connection = Connection(source_population,
target_population,
nsyn,
weights=weight,
delays=0)
connection_list.append(curr_connection)
# Create simulation:
population_list = background_population_dict.values(
) + internal_population_dict.values()
def f(n):
print 't:', n.t
# if n.t%.001 < 1e-10:
# print 't:', n.t
network = Network(population_list, connection_list, update_callback=f)
return network
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 __init__(self, population_list=[], connection_list=[]):
self.simulation = Network(population_list, connection_list)
