def test_parse_equations():
''' Test the parsing of equation strings '''
# A simple equation
eqs = parse_string_equations('dv/dt = -v / tau : 1')
assert len(eqs.keys()
) == 1 and 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert get_dimensions(eqs['v'].unit) == DIMENSIONLESS
# A complex one
eqs = parse_string_equations('''dv/dt = -(v +
ge + # excitatory conductance
I # external current
)/ tau : volt
dge/dt = -ge / tau_ge : volt
I = sin(2 * pi * f * t) : volt
f : Hz (constant)
b : boolean
n : integer
''')
assert len(eqs.keys()) == 6
assert 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert 'ge' in eqs and eqs['ge'].type == DIFFERENTIAL_EQUATION
assert 'I' in eqs and eqs['I'].type == SUBEXPRESSION
assert 'f' in eqs and eqs['f'].type == PARAMETER
assert 'b' in eqs and eqs['b'].type == PARAMETER
assert 'n' in eqs and eqs['n'].type == PARAMETER
assert eqs['f'].var_type == FLOAT
assert eqs['b'].var_type == BOOLEAN
assert eqs['n'].var_type == INTEGER
assert get_dimensions(eqs['v'].unit) == volt.dim
assert get_dimensions(eqs['ge'].unit) == volt.dim
assert get_dimensions(eqs['I'].unit) == volt.dim
assert get_dimensions(eqs['f'].unit) == Hz.dim
assert eqs['v'].flags == []
assert eqs['ge'].flags == []
assert eqs['I'].flags == []
assert eqs['f'].flags == ['constant']
duplicate_eqs = '''
dv/dt = -v / tau : 1
v = 2 * t : 1
'''
assert_raises(EquationError, lambda: parse_string_equations(duplicate_eqs))
parse_error_eqs = [
'''dv/d = -v / tau : 1
x = 2 * t : 1''', '''dv/dt = -v / tau : 1 : volt
x = 2 * t : 1''', ''' dv/dt = -v / tau : 2 * volt''',
'dv/dt = v / second : boolean'
]
for error_eqs in parse_error_eqs:
assert_raises((ValueError, EquationError, TypeError),
lambda: parse_string_equations(error_eqs))
def test_parse_equations():
''' Test the parsing of equation strings '''
# A simple equation
eqs = parse_string_equations('dv/dt = -v / tau : 1')
assert len(eqs.keys()) == 1 and 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert get_dimensions(eqs['v'].unit) == DIMENSIONLESS
# A complex one
eqs = parse_string_equations('''dv/dt = -(v +
ge + # excitatory conductance
I # external current
)/ tau : volt
dge/dt = -ge / tau_ge : volt
I = sin(2 * pi * f * t) : volt
f : Hz (constant)
b : boolean
n : integer
''')
assert len(eqs.keys()) == 6
assert 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert 'ge' in eqs and eqs['ge'].type == DIFFERENTIAL_EQUATION
assert 'I' in eqs and eqs['I'].type == SUBEXPRESSION
assert 'f' in eqs and eqs['f'].type == PARAMETER
assert 'b' in eqs and eqs['b'].type == PARAMETER
assert 'n' in eqs and eqs['n'].type == PARAMETER
assert eqs['f'].var_type == FLOAT
assert eqs['b'].var_type == BOOLEAN
assert eqs['n'].var_type == INTEGER
assert get_dimensions(eqs['v'].unit) == volt.dim
assert get_dimensions(eqs['ge'].unit) == volt.dim
assert get_dimensions(eqs['I'].unit) == volt.dim
assert get_dimensions(eqs['f'].unit) == Hz.dim
assert eqs['v'].flags == []
assert eqs['ge'].flags == []
assert eqs['I'].flags == []
assert eqs['f'].flags == ['constant']
duplicate_eqs = '''
dv/dt = -v / tau : 1
v = 2 * t : 1
'''
assert_raises(EquationError, lambda: parse_string_equations(duplicate_eqs))
parse_error_eqs = [
'''dv/d = -v / tau : 1
x = 2 * t : 1''',
'''dv/dt = -v / tau : 1 : volt
x = 2 * t : 1''',
''' dv/dt = -v / tau : 2 * volt''',
'dv/dt = v / second : boolean']
for error_eqs in parse_error_eqs:
assert_raises((ValueError, EquationError, TypeError),
lambda: parse_string_equations(error_eqs))
def test_parse_equations():
''' Test the parsing of equation strings '''
# A simple equation
eqs = parse_string_equations('dv/dt = -v / tau : 1', {}, False, 0)
assert len(eqs.keys()) == 1 and 'v' in eqs and eqs['v'].eq_type == DIFFERENTIAL_EQUATION
assert get_dimensions(eqs['v'].unit) == DIMENSIONLESS
# A complex one
eqs = parse_string_equations('''dv/dt = -(v +
ge + # excitatory conductance
I # external current
)/ tau : volt
dge/dt = -ge / tau_ge : volt
I = sin(2 * pi * f * t) : volt
f : Hz (constant)
''',
{}, False, 0)
assert len(eqs.keys()) == 4
assert 'v' in eqs and eqs['v'].eq_type == DIFFERENTIAL_EQUATION
assert 'ge' in eqs and eqs['ge'].eq_type == DIFFERENTIAL_EQUATION
assert 'I' in eqs and eqs['I'].eq_type == STATIC_EQUATION
assert 'f' in eqs and eqs['f'].eq_type == PARAMETER
assert get_dimensions(eqs['v'].unit) == volt.dim
assert get_dimensions(eqs['ge'].unit) == volt.dim
assert get_dimensions(eqs['I'].unit) == volt.dim
assert get_dimensions(eqs['f'].unit) == Hz.dim
assert eqs['v'].flags == []
assert eqs['ge'].flags == []
assert eqs['I'].flags == []
assert eqs['f'].flags == ['constant']
duplicate_eqs = '''
dv/dt = -v / tau : 1
v = 2 * t : 1
'''
assert_raises(SyntaxError, lambda: parse_string_equations(duplicate_eqs,
{}, False, 0))
parse_error_eqs = [
'''dv/d = -v / tau : 1
x = 2 * t : 1''',
'''dv/dt = -v / tau : 1 : volt
x = 2 * t : 1''',
''' dv/dt = -v / tau : 2 * volt''']
for error_eqs in parse_error_eqs:
assert_raises((ValueError, SyntaxError), lambda: parse_string_equations(error_eqs,
{}, False, 0))
def test_parse_equations():
""" Test the parsing of equation strings """
# A simple equation
eqs = parse_string_equations('dv/dt = -v / tau : 1')
assert len(
eqs) == 1 and 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert eqs['v'].dim is DIMENSIONLESS
# A complex one
eqs = parse_string_equations("""dv/dt = -(v +
ge + # excitatory conductance
I # external current
)/ tau : volt
dge/dt = -ge / tau_ge : volt
I = sin(2 * pi * f * t) : volt
f : Hz (constant)
b : boolean
n : integer
""")
assert len(eqs) == 6
assert 'v' in eqs and eqs['v'].type == DIFFERENTIAL_EQUATION
assert 'ge' in eqs and eqs['ge'].type == DIFFERENTIAL_EQUATION
assert 'I' in eqs and eqs['I'].type == SUBEXPRESSION
assert 'f' in eqs and eqs['f'].type == PARAMETER
assert 'b' in eqs and eqs['b'].type == PARAMETER
assert 'n' in eqs and eqs['n'].type == PARAMETER
assert eqs['f'].var_type == FLOAT
assert eqs['b'].var_type == BOOLEAN
assert eqs['n'].var_type == INTEGER
assert eqs['v'].dim is volt.dim
assert eqs['ge'].dim is volt.dim
assert eqs['I'].dim is volt.dim
assert eqs['f'].dim is Hz.dim
assert eqs['v'].flags == []
assert eqs['ge'].flags == []
assert eqs['I'].flags == []
assert eqs['f'].flags == ['constant']
duplicate_eqs = """
dv/dt = -v / tau : 1
v = 2 * t : 1
"""
with pytest.raises(EquationError):
parse_string_equations(duplicate_eqs)
parse_error_eqs = [
"""dv/d = -v / tau : 1
x = 2 * t : 1""", """dv/dt = -v / tau : 1 : volt
x = 2 * t : 1""", """ dv/dt = -v / tau : 2 * volt""",
'dv/dt = v / second : boolean'
]
for error_eqs in parse_error_eqs:
with pytest.raises((ValueError, EquationError, TypeError)):
parse_string_equations(error_eqs)
def test_simple_neurongroup():
"""
Test dictionary representation of simple NeuronGroup
"""
# example 1
eqn = '''dv/dt = (1 - v) / tau : volt'''
tau = 10 * ms
size = 1
grp = NeuronGroup(size, eqn, method='exact')
neuron_dict = collect_NeuronGroup(grp, get_local_namespace(0))
assert neuron_dict['N'] == size
assert neuron_dict['user_method'] == 'exact'
assert neuron_dict['equations']['v']['type'] == DIFFERENTIAL_EQUATION
assert neuron_dict['equations']['v']['unit'] == volt
assert neuron_dict['equations']['v']['var_type'] == FLOAT
with pytest.raises(KeyError):
neuron_dict['equations']['tau']
with pytest.raises(KeyError):
neuron_dict['run_regularly']
eqn_obj = Equations(eqn)
assert neuron_dict['equations']['v']['expr'] == eqn_obj['v'].expr.code
assert neuron_dict['identifiers']['tau'] == 10 * ms
with pytest.raises(KeyError):
neuron_dict['identifiers']['size']
assert neuron_dict['when'] == 'groups'
assert neuron_dict['order'] == 0
# example 2
start_scope()
area = 100 * umetre**2
g_L = 1e-2 * siemens * cm**-2 * area
E_L = 1000
div_2 = 2
dim_2 = 0.02 * amp
Cm = 1 * ufarad * cm**-2 * area
grp = NeuronGroup(
10, '''dv/dt = I_leak / Cm : volt
I_leak = g_L*(E_L - v) : amp''')
grp.run_regularly('v = v / div_2', dt=20 * ms, name='i_am_run_reg_senior')
grp.run_regularly('I_leak = I_leak + dim_2',
dt=10 * ms,
name='i_am_run_reg_junior')
neuron_dict = collect_NeuronGroup(grp, get_local_namespace(0))
assert neuron_dict['N'] == 10
assert neuron_dict['user_method'] is None
assert neuron_dict['when'] == 'groups'
assert neuron_dict['order'] == 0
eqn_str = '''
dv/dt = I_leak / Cm : volt
I_leak = g_L*(E_L - v) : amp
'''
assert neuron_dict['equations']['v']['type'] == DIFFERENTIAL_EQUATION
assert neuron_dict['equations']['v']['unit'] == volt
assert neuron_dict['equations']['v']['var_type'] == FLOAT
parsed = parse_string_equations(eqn_str)
assert neuron_dict['equations']['v']['expr'] == parsed['v'].expr.code
assert neuron_dict['equations']['I_leak']['type'] == SUBEXPRESSION
assert neuron_dict['equations']['I_leak']['unit'] == amp
assert neuron_dict['equations']['I_leak']['var_type'] == FLOAT
assert neuron_dict['equations']['I_leak']['expr'] == 'g_L*(E_L - v)'
assert neuron_dict['identifiers']['g_L'] == g_L
assert neuron_dict['identifiers']['Cm'] == Cm
assert neuron_dict['identifiers']['div_2'] == div_2
assert neuron_dict['identifiers']['dim_2'] == dim_2
with pytest.raises(KeyError):
neuron_dict['events']
with pytest.raises(KeyError):
neuron_dict['identifiers']['area']
assert neuron_dict['run_regularly'][0]['name'] == 'i_am_run_reg_senior'
assert neuron_dict['run_regularly'][1]['name'] == 'i_am_run_reg_junior'
assert neuron_dict['run_regularly'][0]['code'] == 'v = v / div_2'
assert (
neuron_dict['run_regularly'][1]['code'] == 'I_leak = I_leak + dim_2')
assert neuron_dict['run_regularly'][0]['dt'] == 20 * ms
assert neuron_dict['run_regularly'][1]['dt'] == 10 * ms
assert neuron_dict['run_regularly'][0]['when'] == 'start'
assert neuron_dict['run_regularly'][1]['when'] == 'start'
assert neuron_dict['run_regularly'][0]['order'] == 0
assert neuron_dict['run_regularly'][1]['order'] == 0
with pytest.raises(IndexError):
neuron_dict['run_regularly'][2]
m1 = StateMonitor(G,'v',record=9)
M = StateMonitor(G, 'I', record=9)
m2 = SpikeMonitor(P)
net = Network(collect())
net.run(100*ms)
visualise_connectivity(S)
# store("test4","../../Data/test4")
# start_scope()
# G1 = NeuronGroup(10, equ, threshold='v > 0.9', reset='v = 0', method='linear',refractory=1*ms )
# m_g1=StateMonitor(G,'v',record=9)
# net.add(m_g1)
from brian2.equations.equations import parse_string_equations
G.equations._equations['I'] = parse_string_equations("I = (g-h)*30 : 1")['I']
G.equations._equations.pop('I')
G.equations = G.equations+("I = (g-h)*40 : 1")
G.variables._variables['I'].expr = '(g-h)*10'
M.variables._variables['_source_I'].expr = '(__source_I_neurongroup_g-__source_I_neurongroup_h)*10'
S.pre.code = on_pre
# net.run(100*ms)
# net.remove(G)
# net.remove(S)
# net.remove(m1)
# net.remove(M)
# net.remove(m_g1)