def test_sympify(self):
a = sympy.Symbol('a')
self.assertEqual(a, sympy.sympify(Alias('a', 'b + c')))
self.assertEqual(a, sympy.sympify(AnalogReceivePort('a')))
self.assertEqual(a, sympy.sympify(AnalogReducePort('a')))
self.assertEqual(a, sympy.sympify(Constant('a', 1.0,
units=un.unitless)))
def test_nonlinear_state_assignment_in_onevent(self):
"""Test that nonlinear state assignements in on events"""
g = Dynamics(name='G',
regimes=[
Regime('dSV1/dt = -SV1 / P1',
'dSV2/dt = -SV2 / P1 + ARP1 * P2',
name='R1',
transitions=[
OnEvent('ERP1',
state_assignments=[
StateAssignment(
'SV2', 'SV2 + A2')
])
])
],
aliases=['A1:=SV1 * C1', 'A2:=P3 * P4 / ADP1'],
analog_ports=[
AnalogReceivePort('ARP1', dimension=un.per_time),
AnalogReducePort('ADP1',
operator='+',
dimension=un.dimensionless),
AnalogSendPort('A1', dimension=un.current),
AnalogSendPort('A2', dimension=un.dimensionless)
],
event_ports=[EventReceivePort('ERP1')],
parameters=[
Parameter('P1', dimension=un.time),
Parameter('P2', dimension=un.dimensionless),
Parameter('P3', dimension=un.resistance),
Parameter('P4', dimension=un.conductance)
],
constants=[Constant('C1', 10, units=un.nA)])
self.assertFalse(g.is_linear())
def test_unused_reduce_ports(self):
"""
Tests whether empty reduce ports are "closed" by inserting a zero-
valued constant in their stead
"""
test_dyn = Dynamics(
name='TestDyn',
regimes=[Regime('dSV1/dt = -P1/t + ADP1', name='r1')],
analog_ports=[AnalogReducePort('ADP1', un.per_time)],
parameters=['P1'])
test_multi = MultiDynamics(name="TestMultiDyn",
sub_components={'cell': test_dyn})
self.assert_(
Constant('ADP1__cell', 0.0,
un.per_time.origin.units) in test_multi.constants,
"Zero-valued constant wasn't inserted for unused reduce "
"port")
StateAssignment('SV1', 'P1 + random.uniform()')
])
],
name='R1',
),
Regime(name='R2',
transitions=[
On('SV1 > 1', to='R1'),
On('SV3 < 0.001',
to='R2',
do=[StateAssignment('SV3', '2 * random.normal()')])
])
],
constants=[Constant('C1', 10.0 * un.mA, un.nA)],
analog_receive_ports=[AnalogReceivePort('ARP1', dimension=un.current)],
analog_reduce_ports=[AnalogReducePort('ADP1', operator='+')],
analog_send_ports=[
AnalogSendPort('A1'),
AnalogSendPort('A2'),
AnalogSendPort('SV3')
],
event_send_ports=[EventSendPort('ESP1')],
event_receive_ports=[EventReceivePort('ERP1')],
parameters=['P1', 'P2', 'P3'])
dynC = Dynamics(
name='dynC',
aliases=['A1:=P1', 'A2 := ARP1 + SV2', 'A3 := SV1'],
regimes=[
Regime(
'dSV1/dt = -SV1 / (P2*t)',
def get_compound_component():
"""Cannot yet be implemented in PyDSTool
"""
from nineml.abstraction.testing_utils import RecordValue
from nineml.abstraction import Dynamics, Regime, On, OutputEvent, AnalogSendPort, AnalogReducePort
emitter = Dynamics(
name='EventEmitter',
parameters=['cyclelength'],
regimes=[
Regime(transitions=On('t > tchange + cyclelength',
do=[OutputEvent('emit'), 'tchange=t'])),
])
ev_based_cc = Dynamics(
name='EventBasedCurrentClass',
parameters=['dur', 'i'],
analog_ports=[AnalogSendPort('I')],
regimes=[
Regime(transitions=[
On('inputevent', do=['I=i', 'tchange = t']),
On('t>tchange + dur', do=['I=0', 'tchange=t'])
])
])
pulsing_emitter = Dynamics(name='pulsing_cc',
subnodes={
'evs': emitter,
'cc': ev_based_cc
},
portconnections=[('evs.emit', 'cc.inputevent')])
nrn = Dynamics(
name='LeakyNeuron',
parameters=['Cm', 'gL', 'E'],
regimes=[
Regime('dV/dt = (iInj + (E-V)*gL )/Cm'),
],
aliases=['iIn := iInj'],
analog_ports=[
AnalogSendPort('V'),
AnalogReducePort('iInj', operator='+')
],
)
combined_comp = Dynamics(name='Comp1',
subnodes={
'nrn': nrn,
'cc1': pulsing_emitter,
'cc2': pulsing_emitter
},
portconnections=[('cc1.cc.I', 'nrn.iInj'),
('cc2.cc.I', 'nrn.iInj')])
combined_comp = al.flattening.flatten(combined_comp)
## records = [
## RecordValue(what='cc1_cc_I', tag='Current', label='Current Clamp 1'),
## RecordValue(what='cc2_cc_I', tag='Current', label='Current Clamp 2'),
## RecordValue(what='nrn_iIn', tag='Current', label='Total Input Current'),
## RecordValue(what='nrn_V', tag='Voltage', label='Neuron Voltage'),
## RecordValue(what='cc1_cc_tchange', tag='Tchange', label='tChange CC1'),
## RecordValue(what='cc2_cc_tchange', tag='Tchange', label='tChange CC2'),
## RecordValue(what='regime', tag='Regime', label='Regime'),
## ]
parameters = al.flattening.ComponentFlattener.flatten_namespace_dict({
'cc1.cc.i':
13.8,
'cc1.cc.dur':
10,
'cc1.evs.cyclelength':
30,
'cc2.cc.i':
20.8,
'cc2.cc.dur':
5.0,
'cc2.evs.cyclelength':
20,
'nrn.gL':
4.3,
'nrn.E':
-70
})
return combined_comp, parameters
def test_analog_ports(self):
# Signature: name
# No Docstring
c = Dynamics(name='C1')
self.assertEqual(len(list(c.analog_ports)), 0)
c = Dynamics(name='C1')
self.assertEqual(len(list(c.analog_ports)), 0)
c = Dynamics(name='C1', aliases=['A:=2'],
analog_ports=[AnalogSendPort('A')])
self.assertEqual(len(list(c.analog_ports)), 1)
self.assertEqual(list(c.analog_ports)[0].mode, 'send')
self.assertEqual(len(list(c.analog_send_ports)), 1)
self.assertEqual(len(list(c.analog_receive_ports)), 0)
self.assertEqual(len(list(c.analog_reduce_ports)), 0)
c = Dynamics(name='C1', analog_ports=[AnalogReceivePort('B')])
self.assertEqual(len(list(c.analog_ports)), 1)
self.assertEqual(list(c.analog_ports)[0].mode, 'recv')
self.assertEqual(len(list(c.analog_send_ports)), 0)
self.assertEqual(len(list(c.analog_receive_ports)), 1)
self.assertEqual(len(list(c.analog_reduce_ports)), 0)
c = Dynamics(name='C1',
analog_ports=[AnalogReducePort('B', operator='+')])
self.assertEqual(len(list(c.analog_ports)), 1)
self.assertEqual(list(c.analog_ports)[0].mode, 'reduce')
self.assertEqual(list(c.analog_ports)[0].operator, '+')
self.assertEqual(len(list(c.analog_send_ports)), 0)
self.assertEqual(len(list(c.analog_receive_ports)), 0)
self.assertEqual(len(list(c.analog_reduce_ports)), 1)
# Duplicate Port Names:
self.assertRaises(
NineMLUsageError,
Dynamics,
name='C1',
aliases=['A1:=1'],
analog_ports=[AnalogReducePort('B', operator='+'),
AnalogSendPort('B')]
)
self.assertRaises(
NineMLUsageError,
Dynamics,
name='C1',
aliases=['A1:=1'],
analog_ports=[AnalogSendPort('A'), AnalogSendPort('A')]
)
self.assertRaises(
NineMLUsageError,
Dynamics,
name='C1',
aliases=['A1:=1'],
analog_ports=[AnalogReceivePort('A'), AnalogReceivePort('A')]
)
self.assertRaises(
NineMLUsageError,
lambda: Dynamics(name='C1', analog_ports=[AnalogReceivePort('1')])
)
self.assertRaises(
NineMLUsageError,
lambda: Dynamics(name='C1', analog_ports=[AnalogReceivePort('?')])
)
def setUp(self):
self.a = Dynamics(
name='A',
aliases=[
'A1:=P1 / P2', 'A2 := ARP2 + P3', 'A3 := A4 * P4 * P5',
'A4:=P6 ** 2 + ADP1', 'A5:=SV1 * SV2 * P8',
'A6:=SV1 * P1 / P8', 'A7:=A1 / P8'
],
regimes=[
Regime('dSV1/dt = -A1 / A2',
'dSV2/dt = -ADP1 / P7',
'dSV3/dt = -A1 * A3 / (A2 * C1)',
transitions=[
OnCondition('SV1 > 10', target_regime_name='R2')
],
aliases=[
Alias('A1', 'P1 / P2 * 2'),
Alias('A5', 'SV1 * SV2 * P8 * 2')
],
name='R1'),
Regime('dSV1/dt = -A1 / A2',
'dSV3/dt = -A1 / A2 * A4',
transitions=[
OnCondition('C2 > A6',
state_assignments=[
StateAssignment('SV1', 'SV1 - A7')
],
target_regime_name='R1')
],
name='R2')
],
analog_ports=[
AnalogReceivePort('ARP1', dimension=un.resistance),
AnalogReceivePort('ARP2', dimension=un.charge),
AnalogReducePort('ADP1', dimension=un.dimensionless),
AnalogSendPort('A5', dimension=un.current)
],
parameters=[
Parameter('P1', dimension=un.voltage),
Parameter('P2', dimension=un.resistance),
Parameter('P3', dimension=un.charge),
Parameter('P4', dimension=old_div(un.length, un.current**2)),
Parameter('P5', dimension=old_div(un.current**2, un.length)),
Parameter('P6', dimension=un.dimensionless),
Parameter('P7', dimension=un.time),
Parameter('P8', dimension=un.current)
],
constants=[
Constant('C1', value=10.0, units=un.unitless),
Constant('C2', value=1.0, units=un.ohm)
])
self.ref_substituted_a = Dynamics(
name='substituted_A',
aliases=['A5:=SV1 * SV2 * P8'],
regimes=[
Regime('dSV1/dt = -2 * (P1 / P2) / (ARP2 + P3)',
'dSV2/dt = -ADP1 / P7',
('dSV3/dt = -2 * (P1 / P2) * ((P6 ** 2 + ADP1) * P4 * '
'P5) / ((ARP2 + P3) * C1)'),
transitions=[
OnCondition('SV1 > 10', target_regime_name='R2')
],
aliases=[Alias('A5', 'SV1 * SV2 * P8 * 2')],
name='R1'),
Regime('dSV1/dt = -(P1 / P2) / (ARP2 + P3)',
'dSV3/dt = -(P1 / P2) / (ARP2 + P3) * (P6 ** 2 + ADP1)',
transitions=[
OnCondition('C2 > (SV1 * P1 / P8)',
state_assignments=[
StateAssignment(
'SV1', 'SV1 - (P1 / P2) / P8')
],
target_regime_name='R1')
],
name='R2')
],
analog_ports=[
AnalogReceivePort('ARP1', dimension=un.resistance),
AnalogReceivePort('ARP2', dimension=un.charge),
AnalogReducePort('ADP1', dimension=un.dimensionless),
AnalogSendPort('A5', dimension=un.current)
],
parameters=[
Parameter('P1', dimension=un.voltage),
Parameter('P2', dimension=un.resistance),
Parameter('P3', dimension=un.charge),
Parameter('P4', dimension=old_div(un.length, un.current**2)),
Parameter('P5', dimension=old_div(un.current**2, un.length)),
Parameter('P6', dimension=un.dimensionless),
Parameter('P7', dimension=un.time),
Parameter('P8', dimension=un.current)
],
constants=[
Constant('C1', value=10.0, units=un.unitless),
Constant('C2', value=1.0, units=un.ohm)
])
def setUp(self):
liaf = Dynamics(
name='liaf',
parameters=[
Parameter(name='R', dimension=un.resistance),
Parameter(name='Vreset', dimension=un.voltage),
Parameter(name='tau', dimension=un.time),
Parameter(name='tau_rp', dimension=un.time),
Parameter(name='theta', dimension=un.voltage)
],
analog_ports=[
AnalogReducePort(name='Isyn',
dimension=un.current,
operator='+'),
AnalogSendPort(name='V', dimension=un.voltage),
AnalogSendPort(name='t_rpend', dimension=un.time)
],
event_ports=[EventSendPort(name='spikeOutput')],
state_variables=[
StateVariable(name='V', dimension=un.voltage),
StateVariable(name='t_rpend', dimension=un.time)
],
regimes=[
Regime(name='refractoryRegime',
transitions=[
OnCondition('t > t_rpend',
target_regime_name='subthresholdRegime')
]),
Regime(
name='subthresholdRegime',
time_derivatives=[TimeDerivative('V', '(Isyn*R - V)/tau')],
transitions=[
OnCondition('V > theta',
target_regime_name='refractoryRegime',
state_assignments=[
StateAssignment('V', 'Vreset'),
StateAssignment(
't_rpend', 't + tau_rp')
],
output_events=[OutputEvent('spikeOutput')])
])
])
poisson = Dynamics(
name='Poisson',
parameters=[Parameter(name='rate', dimension=un.per_time)],
event_ports=[EventSendPort(name='spikeOutput')],
state_variables=[StateVariable(name='t_next', dimension=un.time)],
regimes=[
Regime(name='default',
transitions=[
OnCondition(
't > t_next',
target_regime_name='default',
state_assignments=[
StateAssignment(
't_next', 'one_ms*random.exponential('
'rate*thousand_milliseconds) + t')
],
output_events=[OutputEvent('spikeOutput')])
])
],
constants=[
Constant(name='one_ms', units=un.ms, value=1.0),
Constant(name='thousand_milliseconds',
units=un.ms,
value=1000.0)
])
static = Dynamics(
name='StaticConnection',
analog_ports=[AnalogSendPort(name='weight', dimension=un.current)],
state_variables=[
StateVariable(name='weight', dimension=un.current)
],
regimes=[
Regime(name='default',
time_derivatives=[TimeDerivative('weight', 'zero')])
],
constants=[Constant(name='zero', units=un.A / un.s, value=0.0)])
psr = Dynamics(
name='AlphaPSR',
parameters=[Parameter(name='tau_syn', dimension=un.time)],
event_ports=[EventReceivePort(name='spike')],
analog_ports=[
AnalogReceivePort(name='weight', dimension=un.current),
AnalogSendPort(name='A', dimension=un.current),
AnalogSendPort(name='B', dimension=un.current),
AnalogSendPort(name='Isyn', dimension=un.current)
],
state_variables=[
StateVariable(name='A', dimension=un.current),
StateVariable(name='B', dimension=un.current)
],
regimes=[
Regime(name='default',
time_derivatives=[
TimeDerivative('A', '(-A + B)/tau_syn'),
TimeDerivative('B', '-B/tau_syn')
],
transitions=[
OnEvent('spike',
target_regime_name='default',
state_assignments=[
StateAssignment('B', 'B + weight')
])
])
],
aliases=['Isyn:=A'])
one_to_one_class = ConnectionRule(
'OneToOneClass',
standard_library=(
"http://nineml.net/9ML/1.0/connectionrules/OneToOne"))
self.one_to_one = ConnectionRuleProperties("OneToOne",
one_to_one_class, {})
random_fan_in_class = ConnectionRule(
name="RandomFanIn",
parameters=[Parameter(name="number")],
standard_library=(
"http://nineml.net/9ML/1.0/connectionrules/RandomFanIn"))
exc_random_fan_in = ConnectionRuleProperties(
name="RandomFanInProps",
definition=random_fan_in_class,
properties={'number': 100})
inh_random_fan_in = ConnectionRuleProperties(
name="RandomFanInProps",
definition=random_fan_in_class,
properties={'number': 200})
self.celltype = DynamicsProperties(name="liaf_props",
definition=liaf,
properties={
'tau': self.tau,
'theta': self.theta,
'tau_rp': 2.0 * un.ms,
'Vreset': 10.0 * un.mV,
'R': 1.5 * un.Mohm
},
initial_values={
"V": 0.0 * un.mV,
"t_rpend": 0.0 * un.ms
})
ext_stim = DynamicsProperties(name="stim",
definition=poisson,
properties={'rate': self.input_rate},
initial_values={"t_next": 0.5 * un.ms})
self.psr = DynamicsProperties(name="syn",
definition=psr,
properties={'tau_syn': self.tau_syn},
initial_values={
"A": 0.0 * un.nA,
"B": 0.0 * un.nA
})
exc = Population("Exc", self.order * 4, self.celltype)
inh = Population("Inh", self.order, self.celltype)
ext = Population("Ext", self.order * 5, ext_stim)
exc_and_inh = Selection("All", Concatenate((exc, inh)))
self.static_ext = DynamicsProperties(
"ExternalPlasticity",
static, {},
initial_values={"weight": self.Je * un.nA})
static_exc = DynamicsProperties(
"ExcitatoryPlasticity",
static, {},
initial_values={"weight": self.Je * un.nA})
static_inh = DynamicsProperties(
"InhibitoryPlasticity",
static,
initial_values={"weight": self.Ji * un.nA})
ext_prj = Projection("External",
pre=ext,
post=exc_and_inh,
response=self.psr,
plasticity=self.static_ext,
connection_rule_properties=self.one_to_one,
delay=self.delay,
port_connections=[
('response', 'Isyn', 'post', 'Isyn'),
('plasticity', 'weight', 'response', 'weight')
])
exc_prj = Projection("Excitation",
pre=exc,
post=exc_and_inh,
response=self.psr,
plasticity=static_exc,
connection_rule_properties=exc_random_fan_in,
delay=self.delay,
port_connections=[
('response', 'Isyn', 'post', 'Isyn'),
('plasticity', 'weight', 'response', 'weight')
])
inh_prj = Projection("Inhibition",
pre=inh,
post=exc_and_inh,
response=self.psr,
plasticity=static_inh,
connection_rule_properties=inh_random_fan_in,
delay=self.delay,
port_connections=[
('response', 'Isyn', 'post', 'Isyn'),
('plasticity', 'weight', 'response', 'weight')
])
self.model = Network("brunel_network")
self.model.add(ext)
self.model.add(exc)
self.model.add(inh)
self.model.add(exc_and_inh)
self.model.add(ext_prj)
self.model.add(exc_prj)
self.model.add(inh_prj)
to="refractoryregime"),
),
Regime(
name="refractoryregime",
transitions=[
On("t >= tspike + taurefrac", to="subthresholdregime")
],
)
],
state_variables=[
StateVariable('V', un.voltage),
StateVariable('tspike', un.time),
],
analog_ports=[
AnalogSendPort("V", un.voltage),
AnalogReducePort("ISyn", un.current, operator="+"),
],
event_ports=[
EventSendPort('spikeoutput'),
],
parameters=[
Parameter('cm', un.capacitance),
Parameter('taurefrac', un.time),
Parameter('gl', un.conductance),
Parameter('vreset', un.voltage),
Parameter('vrest', un.voltage),
Parameter('vthresh', un.voltage)
])
coba = Dynamics(name="CobaSyn",
aliases=[
def test_name(self):
# Signature: name
# The name of the port, local to the current component
self.assertEqual(AnalogReceivePort('A').name, 'A')
self.assertEqual(AnalogReducePort('B', operator='+').name, 'B')
self.assertEqual(AnalogSendPort('C').name, 'C')