def test_legacy_params(): """Test reading legacy .param file.""" param_url = ('https://raw.githubusercontent.com/hnnsolver/' 'hnn-core/test_data/default.param') params_legacy_fname = op.join(hnn_core_root, 'param', 'default.param') if not op.exists(params_legacy_fname): _fetch_file(param_url, params_legacy_fname) params_new_fname = op.join(hnn_core_root, 'param', 'default.json') params_legacy = read_params(params_legacy_fname) params_new = read_params(params_new_fname) assert params_new == params_legacy
def calcium_model(params=None, add_drives_from_params=False): """Instantiate the Jones 2009 model with improved calcium dynamics. Returns ------- net : Instance of Network object Network object used to store the Jones 2009 model with an impoved calcium channel distribution. See Also -------- jones_2009_model Notes ----- This model builds on the Jones 2009 model by using a more biologically accurate distribution of calcium channels on L5 pyramidal cells. Specifically, this model introduces a distance dependent maximum conductance (gbar) on calcium channels such that the gbar linearly decreases along the dendrites in the direction of the soma. """ hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') if params is None: params = read_params(params_fname) net = jones_2009_model(params, add_drives_from_params) # Replace L5 pyramidal cell template with updated calcium cell_name = 'L5_pyramidal' pos = net.cell_types[cell_name].pos net.cell_types[cell_name] = pyramidal_ca( cell_name=_short_name(cell_name), pos=pos) return net
def test_add_cell_type(): """Test adding a new cell type.""" params = read_params(params_fname) net = jones_2009_model(params) # instantiate drive events for NetworkBuilder net._instantiate_drives(tstop=params['tstop'], n_trials=params['N_trials']) n_total_cells = net._n_cells pos = [(0, idx, 0) for idx in range(10)] tau1 = 0.6 new_cell = net.cell_types['L2_basket'].copy() net._add_cell_type('new_type', pos=pos, cell_template=new_cell) net.cell_types['new_type'].synapses['gabaa']['tau1'] = tau1 n_new_type = len(net.gid_ranges['new_type']) assert n_new_type == len(pos) net.add_connection('L2_basket', 'new_type', loc='proximal', receptor='gabaa', weight=8e-3, delay=1, lamtha=2) network_builder = NetworkBuilder(net) assert net._n_cells == n_total_cells + len(pos) n_basket = len(net.gid_ranges['L2_basket']) n_connections = n_basket * n_new_type assert len(network_builder.ncs['L2Basket_new_type_gabaa']) == n_connections nc = network_builder.ncs['L2Basket_new_type_gabaa'][0] assert nc.syn().tau1 == tau1
def test_hnn_core(): """Test to check if MNE neuron does not break.""" # small snippet of data on data branch for now. To be deleted # later. Data branch should have only commit so it does not # pollute the history. data_url = ('https://raw.githubusercontent.com/jonescompneurolab/' 'hnn-core/test_data/dpl.txt') if not op.exists('dpl.txt'): _fetch_file(data_url, 'dpl.txt') dpl_master = loadtxt('dpl.txt') hnn_core_root = op.join(op.dirname(hnn_core.__file__), '..') params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) net = Network(params, n_jobs=1) dpl = simulate_dipole(net)[0] fname = './dpl2.txt' dpl.write(fname) dpl_pr = loadtxt(fname) assert_array_equal(dpl_pr[:, 2], dpl_master[:, 2]) # L2 assert_array_equal(dpl_pr[:, 3], dpl_master[:, 3]) # L5
def test_str_to_net(): """Test reading the network via a string""" hnn_core_root = op.dirname(hnn_core.__file__) # prepare network params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) net = Network(params, add_drives_from_params=True) pickled_net = _pickle_data(net) input_str = '@start_of_net@' + pickled_net.decode() + \ '@end_of_net:%d@\n' % (len(pickled_net)) received_net = _str_to_net(input_str) assert isinstance(received_net, Network) # muck with the data size in the signal input_str = '@start_of_net@' + pickled_net.decode() + \ '@end_of_net:%d@\n' % (len(pickled_net) + 1) expected_string = "Got incorrect network size: %d bytes " % \ len(pickled_net) + "expected length: %d" % \ (len(pickled_net) + 1) # process input from queue with pytest.raises(ValueError, match=expected_string): _str_to_net(input_str)
def test_external_common_feeds(): """Test external common feeds to proximal and distal dendrites.""" hnn_core_root = op.join(op.dirname(hnn_core.__file__), '..') params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) # default parameters have no common inputs (distal or proximal), params.update({'input_dist_A_weight_L2Pyr_ampa': 5.4e-5, 'input_dist_A_weight_L5Pyr_ampa': 5.4e-5, 't0_input_dist': 50, 'input_prox_A_weight_L2Pyr_ampa': 5.4e-5, 'input_prox_A_weight_L5Pyr_ampa': 5.4e-5, 't0_input_prox': 50}) with Network(deepcopy(params)) as net: net._create_all_spike_sources() assert len(net.common_feeds) == 2 # (distal & proximal) for ei in net.common_feeds: assert ei.feed_type == 'common' assert ei.cell_type is None # artificial cell assert hasattr(ei, 'nrn_eventvec') assert hasattr(ei, 'nrn_vecstim') assert ei.nrn_eventvec.hname().startswith('Vector') assert hasattr(ei.nrn_vecstim, 'play') # parameters should lead to > 0 input spikes assert len(ei.nrn_eventvec.as_numpy()) > 0 # check that ei.p_ext matches params loc = ei.params['loc'][:4] # loc=prox or dist for layer in ['L2', 'L5']: key = 'input_{}_A_weight_{}Pyr_ampa'.format(loc, layer) assert ei.params[layer + 'Pyr_ampa'][0] == params[key]
def test_split_by_evinput(): """Test splitting evoked input.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) timing_range_multiplier = 3.0 sigma_range_multiplier = 50.0 synweight_range_multiplier = 500.0 decay_multiplier = 1.6 evinput_params = _split_by_evinput(params, sigma_range_multiplier, timing_range_multiplier, synweight_range_multiplier) assert list(evinput_params.keys()) == [ 'evprox_1', 'evdist_1', 'evprox_2'] for evinput in evinput_params.values(): assert list(evinput.keys()) == ['mean', 'sigma', 'ranges', 'start', 'end'] evinput_params = _generate_weights(evinput_params, params, decay_multiplier) for evinput in evinput_params.values(): assert list(evinput.keys()) == ['ranges', 'start', 'end', 'weights', 'opt_start', 'opt_end']
def __init__(self, parent, paramfn): super(BaseParamDialog, self).__init__(parent) self.proxparamwin = None self.distparamwin = None self.netparamwin = None self.syngainparamwin = None self.runparamwin = RunParamDialog(self, parent) self.cellparamwin = CellParamDialog(self) self.netparamwin = NetworkParamDialog(self) self.syngainparamwin = SynGainParamDialog(self, self.netparamwin) self.proxparamwin = OngoingInputParamDialog(self, 'Proximal') self.distparamwin = OngoingInputParamDialog(self, 'Distal') self.evparamwin = EvokedInputParamDialog(self, None) self.optparamwin = OptEvokedInputParamDialog(self, parent) self.poisparamwin = PoissonInputParamDialog(self, None) self.tonicparamwin = TonicInputParamDialog(self, None) self.lsubwin = [self.runparamwin, self.cellparamwin, self.netparamwin, self.proxparamwin, self.distparamwin, self.evparamwin, self.poisparamwin, self.tonicparamwin, self.optparamwin] self.paramfn = paramfn self.parent = parent self.params = read_params(self.paramfn) self.initUI() # requires self.params self.updateDispParam(self.params)
def test_dipole(): """Test dipole object.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') dpl_out_fname = '/tmp/dpl1.txt' params = read_params(params_fname) times = np.random.random(6000) data = np.random.random((6000, 3)) dipole = Dipole(times, data) dipole.baseline_renormalize(params) dipole.convert_fAm_to_nAm() dipole.scale(params['dipole_scalefctr']) dipole.smooth(params['dipole_smooth_win'] / params['dt']) dipole.plot(show=False) viz.plot_dipole([dipole, dipole], show=False) dipole.write(dpl_out_fname) dipole_read = read_dipole(dpl_out_fname) assert_allclose(dipole_read.times, dipole.times, rtol=0, atol=0.00051) for dpl_key in dipole.data.keys(): assert_allclose(dipole_read.data[dpl_key], dipole.data[dpl_key], rtol=0, atol=0.000051) # average two identical dipole objects dipole_avg = average_dipoles([dipole, dipole_read]) for dpl_key in dipole_avg.data.keys(): assert_allclose(dipole_read.data[dpl_key], dipole_avg.data[dpl_key], rtol=0, atol=0.000051) with pytest.raises(ValueError, match="Dipole at index 0 was already an " "average of 2 trials"): dipole_avg = average_dipoles([dipole_avg, dipole_read])
def test_dipole(): """Test params object.""" hnn_core_root = op.join(op.dirname(hnn_core.__file__), '..') params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) with Network(params) as net: net.build() net.cells[0].plot_voltage()
def test_cell(): """Test cells object.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) net = Network(params) with NeuronNetwork(net) as neuron_net: neuron_net.cells[0].plot_voltage()
def __init__(self, params_fname, prior_dict): if 'DISPLAY' in os.environ: del os.environ['DISPLAY'] import hnn_core from hnn_core import simulate_dipole, Network, read_params, JoblibBackend, MPIBackend self.params = read_params(params_fname) #self.params['tstop'] = 100 self.param_names = list(prior_dict.keys())
def test_network_visualization(): """Test network visualisations.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) params.update({'N_pyr_x': 3, 'N_pyr_y': 3}) net = Network(params) plot_cells(net)
def test_dipole(tmpdir, run_hnn_core_fixture): """Test dipole object.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') dpl_out_fname = tmpdir.join('dpl1.txt') params = read_params(params_fname) times = np.random.random(6000) data = np.random.random((6000, 3)) dipole = Dipole(times, data) dipole.baseline_renormalize(params['N_pyr_x'], params['N_pyr_y']) dipole.convert_fAm_to_nAm() dipole.scale(params['dipole_scalefctr']) dipole.smooth(params['dipole_smooth_win'] / params['dt']) dipole.plot(show=False) plot_dipole([dipole, dipole], show=False) dipole.write(dpl_out_fname) dipole_read = read_dipole(dpl_out_fname) assert_allclose(dipole_read.times, dipole.times, rtol=0, atol=0.00051) for dpl_key in dipole.data.keys(): assert_allclose(dipole_read.data[dpl_key], dipole.data[dpl_key], rtol=0, atol=0.000051) # average two identical dipole objects dipole_avg = average_dipoles([dipole, dipole_read]) for dpl_key in dipole_avg.data.keys(): assert_allclose(dipole_read.data[dpl_key], dipole_avg.data[dpl_key], rtol=0, atol=0.000051) with pytest.raises(ValueError, match="Dipole at index 0 was already an " "average of 2 trials"): dipole_avg = average_dipoles([dipole_avg, dipole_read]) # test postproc dpls_raw, net = run_hnn_core_fixture(backend='joblib', n_jobs=1, reduced=True, record_isoma=True, record_vsoma=True, postproc=False) dpls, _ = run_hnn_core_fixture(backend='joblib', n_jobs=1, reduced=True, record_isoma=True, record_vsoma=True, postproc=True) with pytest.raises(AssertionError): assert_allclose(dpls[0].data['agg'], dpls_raw[0].data['agg']) dpls_raw[0].post_proc(net.params['N_pyr_x'], net.params['N_pyr_y'], net.params['dipole_smooth_win'] / net.params['dt'], net.params['dipole_scalefctr']) assert_allclose(dpls_raw[0].data['agg'], dpls[0].data['agg'])
def test_read_legacy_params(): """Test reading of legacy .param file.""" param_url = ('https://raw.githubusercontent.com/hnnsolver/' 'hnn-core/test_data/default.param') params_legacy_fname = op.join(hnn_core_root, 'param', 'default.param') if not op.exists(params_legacy_fname): urlretrieve(param_url, params_legacy_fname) params_new_fname = op.join(hnn_core_root, 'param', 'default.json') params_legacy = read_params(params_legacy_fname) params_new = read_params(params_new_fname) params_new_seedless = {key: val for key, val in params_new.items() if key not in params_new['prng_seedcore*'].keys()} params_legacy_seedless = {key: val for key, val in params_legacy.items() if key not in params_legacy['prng_seedcore*'].keys()} assert params_new_seedless == params_legacy_seedless
def run_hnn_core(backend=None, n_jobs=1): """Test to check if hnn-core does not break.""" # small snippet of data on data branch for now. To be deleted # later. Data branch should have only commit so it does not # pollute the history. data_url = ('https://raw.githubusercontent.com/jonescompneurolab/' 'hnn-core/test_data/dpl.txt') if not op.exists('dpl.txt'): _fetch_file(data_url, 'dpl.txt') dpl_master = loadtxt('dpl.txt') hnn_core_root = op.dirname(hnn_core.__file__) # default params params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) # run the simulation net = Network(params) if backend == 'mpi': with MPIBackend(n_procs=2, mpi_cmd='mpiexec'): dpl = simulate_dipole(net)[0] elif backend == 'joblib': with JoblibBackend(n_jobs=n_jobs): dpl = simulate_dipole(net)[0] else: dpl = simulate_dipole(net)[0] # write the dipole to a file and compare fname = './dpl2.txt' dpl.write(fname) dpl_pr = loadtxt(fname) assert_array_equal(dpl_pr[:, 2], dpl_master[:, 2]) # L2 assert_array_equal(dpl_pr[:, 3], dpl_master[:, 3]) # L5 # Test spike type counts spiketype_counts = {} for spikegid in net.spikes.gids[0]: if net.gid_to_type(spikegid) not in spiketype_counts: spiketype_counts[net.gid_to_type(spikegid)] = 0 else: spiketype_counts[net.gid_to_type(spikegid)] += 1 assert 'common' not in spiketype_counts assert 'exgauss' not in spiketype_counts assert 'extpois' not in spiketype_counts assert spiketype_counts == { 'evprox1': 269, 'L2_basket': 54, 'L2_pyramidal': 113, 'L5_pyramidal': 395, 'L5_basket': 85, 'evdist1': 234, 'evprox2': 269 }
def test_network(): """Test network object.""" hnn_core_root = op.join(op.dirname(hnn_core.__file__), '..') params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) net = Network(deepcopy(params)) for p in params: assert params[p] == net.params[p] assert len(params) == len(net.params) print(net) print(net.cells[:2])
def test_base_params(): """Test default params object matches base params""" param_url = ('https://raw.githubusercontent.com/jonescompneurolab/' 'hnn-core/test_data/base.json') params_base_fname = op.join(hnn_core_root, 'param', 'base.json') if not op.exists(params_base_fname): _fetch_file(param_url, params_base_fname) params_base = read_params(params_base_fname) params = Params() assert params == params_base
def test_tonic_biases(): """Test tonic biases.""" hnn_core_root = op.dirname(hnn_core.__file__) # default params params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) net = hnn_core.Network(params, add_drives_from_params=True) with pytest.raises(ValueError, match=r'cell_type must be one of .*$'): net.add_tonic_bias(cell_type='name_nonexistent', amplitude=1.0, t0=0.0, T=4.0) with pytest.raises(ValueError, match='Duration of tonic input cannot be' ' negative'): net.add_tonic_bias(cell_type='L2_pyramidal', amplitude=1.0, t0=5.0, T=4.0) with pytest.raises(ValueError, match='End time of tonic input cannot be' ' negative'): net.add_tonic_bias(cell_type='L2_pyramidal', amplitude=1.0, t0=5.0, T=-1.) with pytest.raises(ValueError, match='parameter may be missing'): params['Itonic_T_L2Pyr_soma'] = 5.0 net = hnn_core.Network(params, add_drives_from_params=True) params.update({ 'N_pyr_x': 3, 'N_pyr_y': 3, 'tstop': 25, 'N_trials': 1, 'dipole_smooth_win': 5, 't_evprox_1': 5, 't_evdist_1': 10, 't_evprox_2': 20, # tonic inputs 'Itonic_A_L2Pyr_soma': 1.0, 'Itonic_t0_L2Pyr_soma': 5.0, 'Itonic_T_L2Pyr_soma': 15.0 }) # old API net = hnn_core.Network(params, add_drives_from_params=True) assert 'tonic' in net.external_biases assert 'L2_pyramidal' in net.external_biases['tonic'] # new API net = hnn_core.Network(params) net.add_tonic_bias(cell_type='L2_pyramidal', amplitude=1.0) assert 'tonic' in net.external_biases assert 'L5_pyramidal' not in net.external_biases['tonic'] assert net.external_biases['tonic']['L2_pyramidal']['t0'] == 0 assert net.external_biases[ 'tonic']['L2_pyramidal']['T'] == net.params['tstop'] with pytest.raises(ValueError, match=r'Tonic bias already defined for.*$'): net.add_tonic_bias(cell_type='L2_pyramidal', amplitude=1.0)
def test_network_visualization(): """Test network visualisations.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) params.update({'N_pyr_x': 3, 'N_pyr_y': 3}) net = jones_2009_model(params) plot_cells(net) ax = net.cell_types['L2_pyramidal'].plot_morphology() assert len(ax.lines) == 8 conn_idx = 0 plot_connectivity_matrix(net, conn_idx, show=False) with pytest.raises(TypeError, match='net must be an instance of'): plot_connectivity_matrix('blah', conn_idx, show_weight=False) with pytest.raises(TypeError, match='conn_idx must be an instance of'): plot_connectivity_matrix(net, 'blah', show_weight=False) with pytest.raises(TypeError, match='show_weight must be an instance of'): plot_connectivity_matrix(net, conn_idx, show_weight='blah') src_gid = 5 plot_cell_connectivity(net, conn_idx, src_gid, show=False) with pytest.raises(TypeError, match='net must be an instance of'): plot_cell_connectivity('blah', conn_idx, src_gid=src_gid) with pytest.raises(TypeError, match='conn_idx must be an instance of'): plot_cell_connectivity(net, 'blah', src_gid) with pytest.raises(TypeError, match='src_gid must be an instance of'): plot_cell_connectivity(net, conn_idx, src_gid='blah') with pytest.raises(ValueError, match='src_gid -1 not a valid cell ID'): plot_cell_connectivity(net, conn_idx, src_gid=-1) # test interactive clicking updates the position of src_cell in plot del net.connectivity[-1] conn_idx = 15 net.add_connection(net.gid_ranges['L2_pyramidal'][::2], 'L5_basket', 'soma', 'ampa', 0.00025, 1.0, lamtha=3.0, probability=0.8) fig = plot_cell_connectivity(net, conn_idx) ax_src, ax_target, _ = fig.axes pos = net.pos_dict['L2_pyramidal'][2] _fake_click(fig, ax_src, [pos[0], pos[1]]) pos_in_plot = ax_target.collections[2].get_offsets().data[0] assert_allclose(pos[:2], pos_in_plot)
def onActivateSimCB(self, paramfn): """load simulation when activating simulation combobox""" if paramfn != self.baseparamwin.paramfn: try: params = read_params(paramfn) except ValueError: QMessageBox.information( self, "HNN", "WARNING: could not" "retrieve parameters from %s" % paramfn) return self.baseparamwin.paramfn = paramfn self.updateDatCanv(params)
def test_network_visualization(): """Test network visualisations.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) params.update({'N_pyr_x': 3, 'N_pyr_y': 3}) net = Network(params) plot_cells(net) with pytest.raises(ValueError, match='Unrecognized cell type'): plot_cell_morphology(cell_types='blah') axes = plot_cell_morphology(cell_types='L2Pyr') assert len(axes) == 1 assert len(axes[0].lines) == 8
def _run_hnn_core_fixture(backend=None, n_procs=None, n_jobs=1, reduced=False, record_vsoma=False, record_isoma=False, postproc=True): hnn_core_root = op.dirname(hnn_core.__file__) # default params params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) if reduced: params.update({ 'N_pyr_x': 3, 'N_pyr_y': 3, 'tstop': 25, 't_evprox_1': 5, 't_evdist_1': 10, 't_evprox_2': 20, 'N_trials': 2 }) net = Network(params) # number of trials simulated assert all( len(src_feed_times) == params['N_trials'] for src_type, src_feed_times in net.feed_times.items() if src_type != 'tonic') if backend == 'mpi': with MPIBackend(n_procs=n_procs, mpi_cmd='mpiexec'): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) elif backend == 'joblib': with JoblibBackend(n_jobs=n_jobs): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) else: dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) return dpls, net
def selParamFileDialog(self): """bring up window to select simulation parameter file""" relative_root_path = os.path.join(os.path.dirname(__file__), '..') hnn_root_dir = os.path.realpath(relative_root_path) qfd = QFileDialog() qfd.setHistory([ os.path.join(get_output_dir(), 'param'), os.path.join(hnn_root_dir, 'param') ]) fn = qfd.getOpenFileName(self, 'Open param file', os.path.join(hnn_root_dir, 'param'), "Param files (*.param)") if len(fn) > 0 and fn[0] == '': # no file selected in dialog return tmpfn = os.path.abspath(fn[0]) try: params = read_params(tmpfn) except ValueError: QMessageBox.information( self, "HNN", "WARNING: could not" "retrieve parameters from %s" % tmpfn) return # check that valid number of trials was given if 'N_trials' not in params or params['N_trials'] == 0: print("Warning: invalid configured number of trials." " Setting 'N_trials' to 1.") params['N_trials'] = 1 # Now update GUI components self.baseparamwin.paramfn = tmpfn # now update the GUI components to reflect the param file selected self.baseparamwin.updateDispParam(params) self.setWindowTitle(self.baseparamwin.paramfn) self.initSimCanvas() # recreate canvas # check if param file exists in combo box already cb_index = self.cbsim.findText(self.baseparamwin.paramfn) self.populateSimCB(cb_index) # populate the combobox if self.sim_data.get_exp_data_size() > 0: self.toggleEnableOptimization(True)
def test_dipole(): """Test params object.""" hnn_core_root = op.join(op.dirname(hnn_core.__file__), '..') params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) times = np.random.random(6000) data = np.random.random((6000, 3)) dipole = Dipole(times, data) dipole.baseline_renormalize(params) dipole.convert_fAm_to_nAm() dipole.scale(params['dipole_scalefctr']) dipole.smooth(params['dipole_smooth_win'] / params['dt']) dipole.plot(layer='agg') dipole.write('/tmp/dpl1.txt')
def _run_hnn_core_fixture(backend=None, n_procs=None, n_jobs=1, reduced=False, record_vsoma=False, record_isoma=False, postproc=True): hnn_core_root = op.dirname(hnn_core.__file__) # default params params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) if reduced: params.update({ 'N_pyr_x': 3, 'N_pyr_y': 3, 'tstop': 40, 't_evprox_1': 5, 't_evdist_1': 10, 't_evprox_2': 20, 'N_trials': 2 }) net = Network(params, add_drives_from_params=True) # number of trials simulated for drive in net.external_drives.values(): assert len(drive['events']) == params['N_trials'] if backend == 'mpi': with MPIBackend(n_procs=n_procs, mpi_cmd='mpiexec'): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) elif backend == 'joblib': with JoblibBackend(n_jobs=n_jobs): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) else: dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc) return dpls, net
def updateSelectedSim(self, sim_idx): """Update the sim shown in the ComboBox""" paramfn = self.cbsim.itemText(sim_idx) try: params = read_params(paramfn) except ValueError: QMessageBox.information( self, "HNN", "WARNING: could not" "retrieve parameters from %s" % paramfn) return self.baseparamwin.paramfn = paramfn # update GUI self.updateDatCanv(params) self.cbsim.setCurrentIndex(sim_idx)
def _run_hnn_core_fixture(backend=None, n_procs=None, n_jobs=1, reduced=False, record_vsoma=False, record_isoma=False, postproc=False, electrode_array=None): hnn_core_root = op.dirname(hnn_core.__file__) # default params params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) tstop = 170. if reduced: params.update({'N_pyr_x': 3, 'N_pyr_y': 3, 't_evprox_1': 5, 't_evdist_1': 10, 't_evprox_2': 20, 'N_trials': 2}) tstop = 40. net = jones_2009_model(params, add_drives_from_params=True) if electrode_array is not None: for name, positions in electrode_array.items(): net.add_electrode_array(name, positions) if backend == 'mpi': with MPIBackend(n_procs=n_procs, mpi_cmd='mpiexec'): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc, tstop=tstop) elif backend == 'joblib': with JoblibBackend(n_jobs=n_jobs): dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc, tstop=tstop) else: dpls = simulate_dipole(net, record_vsoma=record_isoma, record_isoma=record_vsoma, postproc=postproc, tstop=tstop) # check that the network object is picklable after the simulation pickle.dumps(net) # number of trials simulated for drive in net.external_drives.values(): assert len(drive['events']) == params['N_trials'] return dpls, net
def test_dipole_visualization(): """Test dipole visualisations.""" hnn_core_root = op.dirname(hnn_core.__file__) params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) params.update({'N_pyr_x': 3, 'N_pyr_y': 3, 'tstop': 100.}) net = Network(params) weights_ampa_p = {'L2_pyramidal': 5.4e-5, 'L5_pyramidal': 5.4e-5} syn_delays_p = {'L2_pyramidal': 0.1, 'L5_pyramidal': 1.} net.add_bursty_drive( 'beta_prox', tstart=0., burst_rate=25, burst_std=5, numspikes=1, spike_isi=0, repeats=11, location='proximal', weights_ampa=weights_ampa_p, synaptic_delays=syn_delays_p, seedcore=14) dpls = simulate_dipole(net, n_trials=2, postproc=False) fig = dpls[0].plot() # plot the first dipole alone axes = fig.get_axes()[0] dpls[0].copy().smooth(window_len=10).plot(ax=axes) # add smoothed versions dpls[0].copy().savgol_filter(h_freq=30).plot(ax=axes) # on top # test decimation options plot_dipole(dpls[0], decim=2) for dec in [-1, [2, 2.]]: with pytest.raises(ValueError, match='each decimation factor must be a positive'): plot_dipole(dpls[0], decim=dec) # test plotting multiple dipoles as overlay fig = plot_dipole(dpls) # multiple TFRs get averaged fig = plot_tfr_morlet(dpls, freqs=np.arange(23, 26, 1.), n_cycles=3) with pytest.raises(RuntimeError, match="All dipoles must be scaled equally!"): plot_dipole([dpls[0].copy().scale(10), dpls[1].copy().scale(20)]) with pytest.raises(RuntimeError, match="All dipoles must be scaled equally!"): plot_psd([dpls[0].copy().scale(10), dpls[1].copy().scale(20)]) with pytest.raises(RuntimeError, match="All dipoles must be sampled equally!"): dpl_sfreq = dpls[0].copy() dpl_sfreq.sfreq /= 10 plot_psd([dpls[0], dpl_sfreq])
def test_read_params(): """Test reading of params object.""" params_fname = op.join(hnn_core_root, 'param', 'default.json') params = read_params(params_fname) print(params) print(params['L2Pyr*']) # unsupported extension pytest.raises(ValueError, read_params, 'params.txt') # empty file empty_fname = op.join(hnn_core_root, 'param', 'empty.json') with open(empty_fname, 'w') as json_data: json.dump({}, json_data) pytest.raises(ValueError, read_params, empty_fname) # non dict type pytest.raises(ValueError, Params, []) pytest.raises(ValueError, Params, 'sdfdfdf')