Beispiel #1
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 #2
0
    def simulate(self, duration, nest_rng_seed=12345, neuron_rng_seed=54321):
        """
        Run and the simulation
        """
        if self.simulate_nest:
            nest.ResetKernel()
            simulatorNEST.clear(rng_seed=nest_rng_seed, dt=self.dt)
            simulation_controller.set_delays(self.min_delay, self.max_delay,
                                             self.device_delay)
        if self.simulate_neuron:
            simulatorNEURON.clear(rng_seed=neuron_rng_seed)
            neuron.h.dt = self.dt
        for simulator in self.simulators:
            self._create_9ML(self.nineml_model, self.properties, simulator)
        if self.nest_ref is not None:
            self._create_NEST(self.nest_ref)
        if self.neuron_ref is not None:
            self._create_NEURON(self.neuron_ref)
        if self.simulate_nest:
            simulatorNEST.run(duration)
        if self.simulate_neuron:
            simulatorNEURON.run(duration)

        return self  # return self so it can be chained with subsequent methods