Beispiel #1
0
 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
Beispiel #2
0
    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)))
Beispiel #3
0
 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')
Beispiel #4
0
 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)