def test_in_units_ninemldimensionerror(self):
"""
line #: 499
message: Can't change convert quantity dimension from '{}' to '{}'
"""
qty = Quantity(1.0, un.ms)
self.assertRaises(NineMLDimensionError, qty.in_units, units=un.mV)
def unserialize_node_v1(cls, node, **options): # @UnusedVariable
name = node.attr('name', **options)
value = node.child((SingleValue, ArrayValue, RandomDistributionValue),
**options)
units = node.document[node.attr('units', **options)]
quantity = Quantity(value, units)
return cls(name=name, quantity=quantity)
def test_set_units_ninemldimensionerror(self):
"""
line #: 487
message: Can't change dimension of quantity from '{}' to '{}'
"""
qty = Quantity(1.0, un.ms)
self.assertRaises(NineMLDimensionError, qty.set_units, units=un.mV)
def test___getitem___ninemlruntimeerror(self):
"""
line #: 482
message: Cannot get item from random distribution
"""
random_value = next(
iter(instances_of_all_types['RandomDistributionValue'].values()))
qty = Quantity(random_value, un.ms)
self.assertRaises(NineMLUsageError, qty.__getitem__, index=0)
def test__scaled_value_ninemldimensionerror(self):
"""
line #: 593
message: Cannot scale value as dimensions do not match ('{}' and '{}')
"""
quantity = Quantity(1.0, un.um)
self.assertRaises(NineMLDimensionError,
quantity._scaled_value,
qty=1.0 * un.nF)
def test_pq_round_trip(self):
for unit in self.test_units:
qty = Quantity(1.0, unit)
pq_qty = TestUnitHandler1.to_pq_quantity(qty)
new_qty = TestUnitHandler1.from_pq_quantity(pq_qty)
self.assertEqual(
qty.units.dimension, new_qty.units.dimension,
"Python-quantities roundtrip of '{}' changed "
"dimension".format(unit.name))
new_power = int(math.log10(new_qty.value) + new_qty.units.power)
self.assertEqual(
unit.power, new_power,
"Python-quantities roundtrip of '{}' changed "
"scale ({} -> {})".format(unit.name, unit.power, new_power))
'P4': 152.0 * un.nA
},
initial_values={
'SV1': -1.7 * un.V,
'SV2': 8.1 * un.nA
},
check_initial_values=True)
dynPropB = DynamicsProperties(name='dynPropB',
definition=Definition(dynB),
properties={
'P1':
11.1 * un.unitless,
'P2':
Quantity(
RandomDistributionValue(ranDistrPropA),
un.unitless),
'P3':
-101 * un.unitless
})
dynPropC = DynamicsProperties(
name='dynPropC',
definition=dynC,
properties={
'P1': 23.3 * un.unitless,
'P2': Quantity(ArrayValue([1.0, 2.0, 3.0, 4.0, 5.0]), un.unitless)
},
initial_values=[
Initial('SV1', 3.3 * un.unitless),
Initial('SV2', Quantity(21.7, un.unitless)),
def __init__(self, name, quantity):
super(Property, self).__init__()
assert isinstance(name, basestring)
quantity = Quantity.parse(quantity)
self._name = validate_identifier(name)
self._quantity = quantity
def __init__(self, name, quantity):
super(Property, self).__init__()
assert isinstance(name, basestring)
quantity = Quantity.parse(quantity)
self._name = validate_identifier(name)
self._quantity = quantity
def _create_NEST(self, nest_name):
trans_params = {}
for prop in self.properties.properties:
name = prop.name
value = prop.value
try:
varname, scale = self.nest_translations[name]
value = value * scale
except (ValueError, KeyError):
varname = self.nest_translations.get(name, name)
value = UnitHandlerNEST.scale_value(Quantity(value, prop.units))
if varname is not None:
trans_params[varname] = value
self.nest_cell = nest.Create(nest_name, 1, trans_params)
try:
receptor_types = nest.GetDefaults(nest_name)['receptor_types']
except KeyError:
receptor_types = None
if self.input_signal is not None:
port_name, signal = self.input_signal
generator = nest.Create(
'step_current_generator', 1, {
'amplitude_values':
numpy.ravel(pq.Quantity(signal, 'pA')),
'amplitude_times':
numpy.ravel(numpy.asarray(signal.times.rescale(pq.ms))) -
self.device_delay,
'start':
float(signal.t_start.rescale(pq.ms)),
'stop':
float(signal.t_stop.rescale(pq.ms))
})
nest.Connect(
generator,
self.nest_cell,
syn_spec={
'receptor_type':
(receptor_types[port_name] if receptor_types else 0),
'delay':
self.device_delay
})
if self.input_train is not None:
port_name, signal, connection_properties = self.input_train
try:
_, scale = self.nest_translations[port_name]
except KeyError:
scale = 1.0
# FIXME: Should scale units
weight = connection_properties[0].value * scale
spike_times = (numpy.asarray(signal.rescale(pq.ms)) -
self.device_delay)
if any(spike_times < 0.0):
raise Pype9RuntimeError(
"Some spike are less than minimum delay and so can't be "
"played into cell ({})".format(', '.join(
str(t) for t in spike_times[
spike_times < self.device_delay])))
generator = nest.Create('spike_generator', 1,
{'spike_times': spike_times})
nest.Connect(
generator,
self.nest_cell,
syn_spec={
'receptor_type':
(receptor_types[port_name] if receptor_types else 0),
'delay':
self.device_delay,
'weight':
float(weight)
})
self.nest_multimeter = nest.Create(
'multimeter', 1, {"interval": self.to_float(self.dt, 'ms')})
nest.SetStatus(self.nest_multimeter,
{'record_from': [self.nest_state_variable]})
nest.Connect(self.nest_multimeter,
self.nest_cell,
syn_spec={'delay': self.device_delay})
trans_states = {}
for name, qty in self.initial_states.items():
try:
varname, scale = self.nest_translations[name]
qty = qty * scale
except (ValueError, KeyError):
varname = self.nest_translations.get(name, name)
value = UnitHandlerNEST.scale_value(qty)
if varname is not None:
trans_states[varname] = value
nest.SetStatus(self.nest_cell, trans_states)
def _create_NEURON(self, neuron_name):
# -----------------------------------------------------------------
# Set up NEURON section
# -----------------------------------------------------------------
self.nrn_cell_sec = neuron.h.Section()
try:
self.nrn_cell = eval(
'neuron.h.{}(0.5, sec=self.nrn_cell_sec)'.format(neuron_name))
except TypeError:
self.nrn_cell_sec.insert(neuron_name)
self.nrn_cell = getattr(self.nrn_cell_sec(0.5), neuron_name)
self.nrn_cell_sec.L = 10
self.nrn_cell_sec.diam = 10 / numpy.pi
self.nrn_cell_sec.cm = 1.0
for mech_name in self.extra_mechanisms:
self.nrn_cell_sec.insert(mech_name)
if self.extra_point_process is not None:
MechClass = getattr(neuron.h, self.extra_point_process)
self.extra_point_process = MechClass(self.nrn_cell_sec(0.5))
for prop in self.properties.properties:
name = prop.name
value = prop.value
try:
varname, scale = self.neuron_translations[name]
value = value * scale
except (ValueError, KeyError):
varname = self.neuron_translations.get(name, name)
if varname in self.specific_params:
specific_value = (Quantity(value, prop.units) /
(100 * un.um**2))
value = UnitHandlerNEURON.scale_value(specific_value)
else:
value = UnitHandlerNEURON.scale_value(
Quantity(value, prop.units))
if varname is not None:
if '.' in varname:
mech_name, vname = varname.split('.')
try:
setattr(getattr(self.nrn_cell_sec(0.5), mech_name),
vname, value)
except AttributeError:
setattr(self.extra_point_process, vname, value)
elif varname == 'cm':
self.nrn_cell_sec.cm = value
else:
try:
setattr(self.nrn_cell, varname, value)
except AttributeError:
setattr(self.nrn_cell_sec, varname, value)
for name, value in self.initial_states.items():
try:
varname, scale = self.neuron_translations[name]
value = value * scale
except (ValueError, KeyError):
varname = self.neuron_translations.get(name, name)
value = UnitHandlerNEURON.scale_value(
UnitHandlerNEURON.from_pq_quantity(value))
if varname is not None:
if '.' in varname:
try:
setattr(getattr(self.nrn_cell_sec(0.5), mech_name),
vname, value)
except AttributeError:
setattr(self.point_process, vname, value)
else:
try:
setattr(self.nrn_cell, varname, value)
except (AttributeError, LookupError):
setattr(self.nrn_cell_sec, varname, value)
# Specify current injection
if self.input_signal is not None:
_, signal = self.input_signal
times = numpy.asarray(signal.times.rescale(pq.ms))
self._nrn_iclamp = neuron.h.IClamp(0.5, sec=self.nrn_cell_sec)
self._nrn_iclamp.delay = 0.0
self._nrn_iclamp.dur = 1e12
self._nrn_iclamp.amp = 0.0
self._nrn_iclamp_amps = neuron.h.Vector(signal.rescale(pq.nA))
self._nrn_iclamp_times = neuron.h.Vector(times)
self._nrn_iclamp_amps.play(self._nrn_iclamp._ref_amp,
self._nrn_iclamp_times)
if self.input_train is not None:
port_name, train, connection_properties = self.input_train
try:
_, scale = self.neuron_translations[port_name]
except KeyError:
scale = 1.0
# FIXME: Should scale units
weight = connection_properties[0].value * scale
self._vstim = neuron.h.VecStim()
times = numpy.asarray(train.rescale(pq.ms)) - 1.0
self._vstim_times = neuron.h.Vector(times)
self._vstim.play(self._vstim_times)
target = (self.extra_point_process if self.extra_point_process
is not None else self.nrn_cell)
self._vstim_con = neuron.h.NetCon(self._vstim,
target,
sec=self.nrn_cell_sec)
self._vstim_con.weight[0] = weight
# Record Time from NEURON (neuron.h.._ref_t)
self._nrn_rec = self.NEURONRecorder(self.nrn_cell_sec, self.nrn_cell)
self._nrn_rec.record(self.neuron_state_variable)
if init_v is not None:
nest.SetStatus(nodes_exc, 'V_m', init_v['Exc'])
nest.SetStatus(nodes_inh, 'V_m', init_v['Inh'])
else:
nest.SetStatus(nodes_exc + nodes_inh, 'V_m',
list(numpy.random.rand(NE + NI) * 20.0))
if external_input is not None:
nodes_ext = nest.Create("spike_generator",
NE + NI,
params=[{
'spike_times': r
} for r in external_input])
else:
nest.SetDefaults("poisson_generator",
{"rate": float(Quantity(p_rate, un.Hz))})
noise = nest.Create("poisson_generator")
nodes_ext = nest.Create('parrot_neuron', NE + NI)
nest.Connect(noise, nodes_ext)
self._pops = {'Exc': nodes_exc, 'Inh': nodes_inh, 'Ext': nodes_ext}
# Set up connections
nest.CopyModel(
"static_synapse", "excitatory", {
"weight": float(Quantity(J_ex, un.nS)),
"delay": float(Quantity(delay, un.ms))
})
nest.CopyModel(
"static_synapse", "inhibitory", {