def recording(self, port_name): """ Return recorded data as a dictionary containing one numpy array for each neuron, ids as keys. """ # NB: Port could also be a state variable try: port = self.component_class.send_port(port_name) except NineMLNameError: # For convenient access to state variables port = self.component_class.state_variable(port_name) if port.nineml_type in ('EventSendPort', 'EventSendPortExposure'): spikes = nest.GetStatus( self._recorders[port_name], 'events')[0]['times'] data = neo.SpikeTrain(spikes, t_start=0.0 * pq.ms, t_stop=simulation_controller.t * pq.ms, name=port_name, units=pq.ms) else: port_name = self.build_name(port_name) events, interval = nest.GetStatus(self._recorders[port_name], ('events', 'interval'))[0] try: port = self._nineml.component_class.port(port_name) except NineMLNameError: port = self._nineml.component_class.state_variable(port_name) unit_str = UnitHandler.dimension_to_unit_str(port.dimension) variable_name = self.build_name(port_name) data = neo.AnalogSignal( events[variable_name], sampling_period=interval * pq.ms, t_start=0.0 * pq.ms, units=unit_str, name=port_name) return data
def test_poisson(self, duration=10 * un.s, rate=100 * un.Hz, print_comparisons=False, dt=0.001, simulators=['nest', 'neuron'], build_mode='force', **kwargs): # @UnusedVariable @IgnorePep8 nineml_model = ninemlcatalog.load('input/Poisson', 'Poisson') build_args = {'neuron': {'build_mode': build_mode, 'external_currents': ['iSyn']}, 'nest': {'build_mode': build_mode}} initial_states = {'t_next': 0.0 * un.ms} for sim_name in simulators: meta_class = cell_metaclasses[sim_name] # Build celltype celltype = meta_class( nineml_model, name=nineml_model.name, **build_args[sim_name]) # Initialise simulator if sim_name == 'neuron': # Run NEURON simulation import neuron simulatorNEURON.clear(rng_seed=NEURON_RNG_SEED) neuron.h.dt = dt elif sim_name == 'nest': # Run NEST simulation # import nest # nest.ResetKernel() # nest.ResetNetwork() # nest.SetKernelStatus({'resolution': dt}) simulatorNEST.clear(rng_seed=NEST_RNG_SEED, dt=dt) else: assert False # Create and initialise cell cell = celltype(rate=rate) cell.record('spike_output') cell.set_state(initial_states) # Run simulation if sim_name == 'neuron': simulatorNEURON.run(duration.in_units(un.ms)) elif sim_name == 'nest': simulatorNEST.run(duration.in_units(un.ms)) else: assert False # Get recording spikes = cell.recording('spike_output') # Calculate the rate of the modelled process recorded_rate = pq.Quantity( len(spikes) / (spikes.t_stop - spikes.t_start), 'Hz') ref_rate = pq.Quantity(UnitHandlerNEST.to_pq_quantity(rate), 'Hz') rate_difference = abs(ref_rate - recorded_rate) if print_comparisons: print "Reference rate: {}".format(ref_rate) print "{} recorded rate: {}".format(sim_name, recorded_rate) print "{} difference: {}".format(sim_name, rate_difference) self.assertLess( rate_difference, 1.75 * pq.Hz, ("Recorded rate of {} poisson generator ({}) did not match " "desired ({}) within {}: difference {}".format( sim_name, recorded_rate, ref_rate, 1.75 * pq.Hz, recorded_rate - ref_rate)))
def test_scaling_and_assignment(self): handler1 = TestUnitHandler1(self.a) handler2 = NestUnitHandler(self.a) self.assertEqual(handler1.scale_alias('A2'), (Expression('ARP2 + P3'), 'ms*nA')) self.assertEqual(handler1.scale_alias('A4'), (Expression('ARP3 + 100/(P2*P6)'), 'S/cm2')) self.assertEqual(handler1.scale_alias('A5'), (Expression('P7 * P8'), 'mV')) self.assertEqual(handler1.scale_alias('A6'), (Expression('1e-3 * P9/P10'), 'ms')) self.assertEqual( handler2.scale_time_derivative(self.a.regime('R1').element('SV2')), (Expression('C1 * SV2 ** 2 + C2 * SV2 + C3 + SV3 + ' 'ARP4 / P11'), 'mV/ms')) self.assertEqual( handler2.scale_time_derivative(self.a.regime('R1').element('SV3')), (Expression('P12*(SV2*P13 - SV3)'), 'mV/ms^2')) self.assertEqual(handler1.assign_units_to_variable('P2'), '1/uS') self.assertEqual(handler1.assign_units_to_variable('P6'), 'um^2')
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': pq.Quantity(signal, 'pA'), 'amplitude_times': (pq.Quantity(signal.times, 'ms') - self.device_delay * pq.ms), 'start': float(pq.Quantity(signal.t_start, 'ms')), 'stop': float(pq.Quantity(signal.t_stop, '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 = (pq.Quantity(signal, 'ms') + (pq.ms - self.device_delay * pq.ms)) 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': float(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) trans_states = {} for name, qty in self.initial_states.iteritems(): 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)