def bind_score_to_dtc(dtc): #import evaluate_as_module from neuronunit.optimization import evaluate_as_module #from neuronunit.models import backends from neuronunit.models.reduced import ReducedModel import quantities as pq import numpy as np from neuronunit.optimization import get_neab model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURONMemory') model.set_attrs(dtc.attrs) get_neab.tests[0].prediction = dtc.rheobase model.rheobase = dtc.rheobase['value'] if dtc.rheobase['value'] <= 0.0: return dtc for k, t in enumerate(get_neab.tests): if k > 0: t.params = dtc.vtest[k] score = t.judge(model, stop_on_error=False, deep_error=False) #import pdb; pdb.set_trace() dtc.scores[str(t)] = score.sort_key try: observation = score.observation prediction = score.prediction delta = evaluate_as_module.difference(observation, prediction) dtc.differences[str(t)] = delta except: pass return dtc
def nunit_evaluation(tuple_object): # Inputs single data transport container modules, and neuroelectro observations that # inform test error error_criterion # Outputs Neuron Unit evaluation scores over error criterion dtc, tests = tuple_object dtc = copy.copy(dtc) dtc.model_path = path_params['model_path'] LEMS_MODEL_PATH = path_params['model_path'] assert dtc.rheobase is not None tests = [t for t in tests if str('RheobaseTestP') not in str(t)] #for t in tests: # dtc.scores[str(t)] = 1.0 for k, t in enumerate(tests): t.params = dtc.vtest[k] score = None model = None model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend=('NEURON', { 'DTC': dtc })) model.set_attrs(dtc.attrs) score = t.judge(model, stop_on_error=False, deep_error=False) if type(score.sort_key) is not type(None): dtc.scores[str(t)] = 1 - score.sort_key dtc = score_proc(dtc, t, copy.copy(score)) else: dtc.scores[str(t)] = 1.0 dtc.get_ss() return dtc '''
def test_rheobase_single_value_parallel_and_serial_comparison(self): from neuronunit.tests.fi import RheobaseTest, RheobaseTestP from neuronunit.optimization import get_neab from neuronunit.models.reduced import ReducedModel from neuronunit import aibs import os dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre # Primary visual area, layer 5 neuron. observation = aibs.get_observation(dataset_id, 'rheobase') rt = RheobaseTest(observation=observation) rtp = RheobaseTestP(observation=observation) model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend=('NEURON')) #model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON') self.score_p = rtp.judge(model, stop_on_error=False, deep_error=True) self.predictionp = self.score_p.prediction self.score_p = self.score_p.norm_score #model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON') serial_model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') self.score_s = rt.judge(serial_model, stop_on_error=False, deep_error=True) self.predictions = self.score_s.prediction self.score_s = self.score_s.norm_score import numpy as np check_less_thresh = float( np.abs(self.predictionp['value'] - self.predictions['value'])) self.assertLessEqual(check_less_thresh, 2.0)
def nunit_evaluation(dtc,error_criterion): # Inputs single data transport container modules, and neuroelectro observations that # inform test error error_criterion # Outputs Neuron Unit evaluation scores over error criterion dtc.model_path = path_params['model_path'] LEMS_MODEL_PATH = path_params['model_path'] assert dtc.rheobase is not None from neuronunit.models.reduced import ReducedModel #from neuronunit.optimization import get_neab tests = error_criterion model = ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON',{'DTC':dtc})) model.set_attrs(dtc.attrs) tests[0].prediction = dtc.rheobase model.rheobase = dtc.rheobase['value'] from dask import dataframe as dd if dtc.score is None: dtc.score = {} for k,t in enumerate(tests[1:-1]): t.params = dtc.vtest[k] print(t.params) score = None score = t.judge(model,stop_on_error = False, deep_error = False) if score.sort_key is not None: # dtc.scores.get(str(t), score.sort_key) # dtc.score.get(str(t), score.sort_key-1) dtc.scores[str(t)] = 1.0 - score.sort_key print(str(t),score.sort_key) if not hasattr(dtc,'score'): dtc.score = {} dtc.score[str(t)] = score.sort_key else: pass return dtc
def dtc_to_rheo(dtc): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab from neuronunit.optimization import evaluate_as_module model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') model.set_attrs(dtc.attrs) #dtc.cell_name = model._backend.cell_name #dtc.current_src_name = model._backend.current_src_name dtc.scores = None dtc.scores = {} dtc.differences = None dtc.differences = {} score = get_neab.tests[0].judge(model, stop_on_error=False, deep_error=True) observation = score.observation prediction = score.prediction delta = evaluate_as_module.difference(observation, prediction) dtc.differences[str(get_neab.tests[0])] = delta dtc.scores[str(get_neab.tests[0])] = score.sort_key dtc.rheobase = score.prediction return dtc
def nunit_evaluation(tuple_object): #,backend=None): # Inputs single data transport container modules, and neuroelectro observations that # inform test error error_criterion # Outputs Neuron Unit evaluation scores over error criterion dtc, tests = tuple_object dtc = copy.copy(dtc) dtc.model_path = path_params['model_path'] LEMS_MODEL_PATH = path_params['model_path'] assert dtc.rheobase is not None backend = dtc.backend if backend == 'glif': model = glif.GC( ) #ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON',{'DTC':dtc})) tests[0].prediction = dtc.rheobase model.rheobase = dtc.rheobase['value'] else: model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend=('NEURON', { 'DTC': dtc })) model.set_attrs(dtc.attrs) tests[0].prediction = dtc.rheobase model.rheobase = dtc.rheobase['value'] for k, t in enumerate(tests[1:-1]): t.params = dtc.vtest[k] score = None score = t.judge(model, stop_on_error=False, deep_error=False) dtc.score[str(t)] = {} dtc.score[str(t)]['value'] = copy.copy(score.sort_key) if hasattr(score, 'prediction'): if type(score.prediction) is not type(None): dtc.score[str(t)][str('prediction')] = score.prediction dtc.score[str(t)][str('observation')] = score.observation if 'mean' in score.observation.keys( ) and 'mean' in score.prediction.keys(): print(score.observation.keys()) dtc.score[str(t)][str('agreement')] = np.abs( score.observation['mean'] - score.prediction['mean']) else: print(score, type(score)) if score.sort_key is not None: ## # This probably does something different to what I thought. ## #dtc.scores.get(str(t), 1.0 - score.sort_key) dtc.scores[str(t)] = 1.0 - score.sort_key else: dtc.scores[str(t)] = 1.0 return dtc
def setUp(self): self.predictions = None self.predictionp = None self.score_p = None self.score_s = None from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab print(get_neab.LEMS_MODEL_PATH) #def create_model(): # cannot be pickled. self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON') self.model = None
def test_frp(self): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend=('NEURON')) attrs = {'a':0.02, 'b':0.2, 'c':-65+15*0.5, 'd':8-0.5**2 } from neuronunit.optimization.data_transport_container import DataTC dtc = DataTC() from neuronunit.tests import fi model.set_attrs(attrs) from neuronunit.optimization import get_neab rtp = get_neab.tests[0] rheobase = rtp.generate_prediction(model) self.assertTrue(float(rheobase['value']))
def dtc_to_rheo(dtc): from neuronunit.optimization import get_neab dtc.scores = {} from neuronunit.models.reduced import ReducedModel model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') model.set_attrs(dtc.attrs) rbt = get_neab.tests[0] score = rbt.judge(model, stop_on_error=False, deep_error=True) dtc.scores[str(rbt)] = score.sort_key observation = score.observation dtc.rheobase = score.prediction return dtc
def check_current(ampl, dtc): ''' Inputs are an amplitude to test and a virtual model output is an virtual model with an updated dictionary. ''' import copy import os import quantities from neuronunit.models.reduced import ReducedModel import neuronunit LEMS_MODEL_PATH = str(neuronunit.__path__[0]) + str( '/models/NeuroML2/LEMS_2007One.xml') dtc.model_path = LEMS_MODEL_PATH model = ReducedModel(dtc.model_path, name='vanilla', backend=(str(dtc.backend), { 'DTC': dtc })) import copy model.set_attrs(dtc.attrs) DELAY = 100.0 * pq.ms DURATION = 1000.0 * pq.ms params = { 'injected_square_current': { 'amplitude': 100.0 * pq.pA, 'delay': DELAY, 'duration': DURATION } } dtc = copy.copy(dtc) ampl = float(ampl) #print(dtc.lookup) if ampl not in dtc.lookup or len(dtc.lookup) == 0: current = params.copy()['injected_square_current'] uc = {'amplitude': ampl} current.update(uc) current = {'injected_square_current': current} dtc.run_number += 1 model.set_attrs(dtc.attrs) model.inject_square_current(current) dtc.previous = ampl n_spikes = model.get_spike_count() dtc.lookup[float(ampl)] = n_spikes if n_spikes == 1: dtc.rheobase = float(ampl) dtc.boolean = True return dtc return dtc if float(ampl) in dtc.lookup: return dtc
def dtc_to_rheo(xargs): dtc,rtest = xargs dtc.model_path = path_params['model_path'] LEMS_MODEL_PATH = path_params['model_path'] model = ReducedModel(LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON') model.set_attrs(dtc.attrs) dtc.scores = {} dtc.score = {} score = rtest.judge(model,stop_on_error = False, deep_error = True) #if bool(model.get_spike_count() == 1 or model.get_spike_count() == 0) if score.sort_key is not None: dtc.scores[str(rtest)] = 1 - score.sort_key #pd.DataFrame([ ]) dtc.rheobase = score.prediction #assert dtc.rheobase is not None return dtc
def setUp(self): self.predictions = None self.predictionp = None self.score_p = None self.score_s = None self.grid_points = grid_points() dtcpop = self.grid_points self.test_compute_score = test_compute_score self.dtcpop = test_compute_score(dtcpop) self.dtc = self.dtcpop[0] self.rheobase = self.dtc.rheobase from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab self.standard_model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON') self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON')
def use_dtc_to_plotting(dtcpop, minimagr): from neuronunit.capabilities import spike_functions import matplotlib.pyplot as plt import numpy as np plt.clf() plt.style.use('ggplot') fig, axes = plt.subplots(figsize=(10, 10), facecolor='white') stored_min = [] stored_max = [] for dtc in dtcpop[1:-1]: plt.plot(dtc.tvec, dtc.vm0, linewidth=3.5, color='grey') stored_min.append(np.min(dtc.vm0)) stored_max.append(np.max(dtc.vm0)) from neuronunit.models.reduced import ReducedModel from neuronunit.optimization.get_neab import tests as T from neuronunit.optimization import get_neab from neuronunit.optimization import evaluate_as_module from neuronunit.optimization.evaluate_as_module import pre_format model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') import neuron model._backend.reset_neuron(neuron) model.set_attrs(minimagr.attrs) model.rheobase = minimagr.rheobase['value'] minimagr = pre_format(minimagr) parameter_list = list(minimagr.vtest.values()) model.inject_square_current(parameter_list[0]) model._backend.local_run() assert model.get_spike_count() == 1 print(model.get_spike_count(), bool(model.get_spike_count() == 1)) brute_best = list(model.results['vm']) plt.plot(dtcpop[0].tvec, brute_best, linewidth=1, color='blue', label='best candidate via grid') #+str(mini.scores)) plt.plot(dtcpop[0].tvec, dtcpop[0].vm0, linewidth=1, color='red', label='best candidate via GA') #+str(miniga.scores)) plt.legend() plt.ylabel('$V_{m}$ mV') plt.xlabel('ms') plt.show()
def dtc_to_rheo(xargs): dtc, rtest, backend = xargs LEMS_MODEL_PATH = path_params['model_path'] model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') model.set_attrs(dtc.attrs) dtc.scores = {} dtc.score = {} score = rtest.judge(model, stop_on_error=False, deep_error=True) if score.sort_key is not None: dtc.scores.get(str(rtest), 1 - score.sort_key) dtc.scores[str(rtest)] = 1 - score.sort_key dtc.rheobase = score.prediction return dtc
def test_rheobase(self): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab import copy import unittest dtc = copy.copy(self.dtc) self.assertNotEqual(self.dtc, None) dtc.scores = {} size = len([v for v in dtc.attrs.values()]) assert size > 0 self.assertGreater(size, 0) model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend=('NEURON', { 'DTC': dtc })) temp = [v for v in model.attrs.values()] assert len(temp) > 0 self.assertGreater(len(temp), 0) rbt = get_neab.tests[0] scoreN = rbt.judge(model, stop_on_error=False, deep_error=True) import copy dtc.scores[str(rbt)] = copy.copy(scoreN.norm_score) assert scoreN.norm_score is not None self.assertTrue(scoreN.norm_score is not None) dtc.rheobase = copy.copy(scoreN.prediction) return dtc
def dtc_to_model(self): if self.backend is str("JULIA"): from neuronunit.models import simple_with_current_injection model = SimpleModel(attrs) if self.backend is str('NEURON') or self.backend is str('jNEUROML'): import neuronunit LEMS_MODEL_PATH = str(neuronunit.__path__[0])+str('/models/NeuroML2/LEMS_2007One.xml') self.model_path = LEMS_MODEL_PATH from neuronunit.models.reduced import ReducedModel#, VeryReducedModel model = ReducedModel(self.model_path,name='vanilla', backend=(self.backend, {'DTC':self})) self.current_src_name = model._backend.current_src_name assert type(self.current_src_name) is not type(None) self.cell_name = model._backend.cell_name model.attrs = self.attrs else: # The most likely outcome from neuronunit.models.very_reduced_sans_lems import VeryReducedModel model = VeryReducedModel(backend=self.backend) model.backend = self.backend model.attrs = self.attrs model.rheobase = self.rheobase try: model.inj = self.params except: try: model.inj = self.vparams except: model.inj = None return model
def as_lems_model(self, backend=None): glif_package = [] glif_package.append(self.metad) glif_package.append(self.nc) glif_package.append(self.get_sweeps) lems_file_path = parse_glif.generate_lems(glif_package) return ReducedModel(lems_file_path, backend=backend)
def test_4rheobase_setup(self): from neuronunit.tests.fi import RheobaseTest, RheobaseTestP from neuronunit.optimization import get_neab from neuronunit.models import backends from neuronunit.models.reduced import ReducedModel import time from neuronunit import aibs import os dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre # Primary visual area, layer 5 neuron. observation = aibs.get_observation(dataset_id,'rheobase') #os.system('ipcluster start -n 8 --profile=default & sleep 25;') rt = RheobaseTest(observation = observation) rtp = RheobaseTestP(observation = observation) get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml' model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON') ticks = time.time() self.score_p = rtp.judge(model,stop_on_error = False, deep_error = True) self.predictionp = self.score_p.prediction self.score_p = self.score_p.sort_key tickp = time.time() self.timed_p = tickp - ticks self.score_s = rt.judge(model,stop_on_error = False, deep_error = True) self.predictions = self.score_s.prediction self.score_s = self.score_s.sort_key self.timed_s = time.time() - tickp print(' serial score {0} parallel score {1}'.format(self.score_s,self.score_p)) print(' serial time {0} parallel time {1}'.format(self.timed_s,self.timed_p))
def nrn_backend_works(self): from neuronunit.optimization import get_neab get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml' #from neuronunit.models import backends from neuronunit.models.reduced import ReducedModel model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON')
def test_10rheobase_setup(self): from neuronunit.tests.fi import RheobaseTest, RheobaseTestP from neuronunit.optimization import get_neab from neuronunit.models.reduced import ReducedModel from neuronunit import aibs import os dataset_id = 354190013 # Internal ID that AIBS uses for a particular Scnn1a-Tg2-Cre # Primary visual area, layer 5 neuron. observation = aibs.get_observation(dataset_id, 'rheobase') rt = RheobaseTest(observation=observation) rtp = RheobaseTestP(observation=observation) model = ReducedModel(get_neab.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') self.score_p = rtp.judge(model, stop_on_error=False, deep_error=True) self.predictionp = self.score_p.prediction self.score_p = self.score_p.sort_key self.score_s = rt.judge(model, stop_on_error=True, deep_error=True) self.predictions = self.score_s.prediction self.score_s = self.score_s.sort_key print(' serial score {0} parallel score {1}'.format( self.score_s, self.score_p)) self.assertEqual(int(self.score_s * 1000), int(self.score_p * 1000)) self.assertEqual(int(self.predictionp['value']), int(self.predictions['value']))
def hack_judge(test_and_models): (test, attrs) = test_and_models model = None obs = test.observation LEMS_MODEL_PATH = path_params['model_path'] model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend=('RAW')) model.set_attrs(attrs) test.generate_prediction(model) pred = test.generate_prediction(model) score = test.compute_score(obs, pred) try: print(obs['value'], pred['value']) except: print(obs['mean'], pred['mean']) return score
def test_2_backend_pyNN(self): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab print(get_neab.LEMS_MODEL_PATH) model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='pyNN') print(model) import pdb pdb.set_trace()
def setUp(self): #from neuronunit import neuroelectro from neuronunit.models.reduced import ReducedModel from .model_tests import ReducedModelTestCase path = ReducedModelTestCase().path self.model = ReducedModel(path, backend='jNeuroML') if not is_neuroelectro_up(): return self.skipTest("Neuroelectro is down")
def parallel_method(item_of_iter_list): from neuronunit.optimization import get_neab get_neab.LEMS_MODEL_PATH = '/home/jovyan/neuronunit/neuronunit/optimization/NeuroML2/LEMS_2007One.xml' #from neuronunit.models import backends from neuronunit.models.reduced import ReducedModel model = ReducedModel(get_neab.LEMS_MODEL_PATH,name=str('vanilla'),backend='NEURON') model.set_attrs(item_of_iter_list) get_neab.tests[0].prediction = dtc.rheobase model.rheobase = dtc.rheobase['value'] scores = [] for k,t in enumerate(get_neab.tests): if k>1: t.params = dtc.vtest[k] score = t.judge(model,stop_on_error = False, deep_error = True) scores.append(score.sort_key,score) return scores
def plot_vm(hof,ax,key): ax.cla() ax.set_title(' {0} vs $V_{M}$'.format(key[0])) best_dtc = hof[0].dtc best_rh = hof[0].dtc.rheobase neuron = None model = ReducedModel(path_params['model_path'],name = str('regular_spiking'),backend =('NEURON',{'DTC':best_dtc})) params = {'injected_square_current': {'amplitude': best_rh, 'delay':DELAY, 'duration':DURATION}} results = modelrs.inject_square_current(params) vm = model.get_membrane_potential() times = vm.times ax.plot(times,vm) #ax.xlabel('ms') #ax.ylabel('mV') #ax.set_xlim(np.min(x),np.max(x)) #ax.set_ylim(np.min(z),np.max(z)) return ax
def test_neuron_set_attrs(self): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab self.assertNotEqual(self.dtcpop,None) dtc = self.dtcpop[0] self.model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend=('NEURON',{'DTC':dtc})) temp = [ v for v in self.model.attrs.values() ] assert len(temp) > 0 self.assertGreater(len(temp),0)
def test_backend_inheritance(self): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab print(get_neab.LEMS_MODEL_PATH) model = ReducedModel(get_neab.LEMS_MODEL_PATH, backend='NEURON') ma = list(dir(model)) if 'get_spike_train' in ma and 'rheobase' in ma: return True else: return False
def dtc_to_rheo(dtc): from neuronunit.models.reduced import ReducedModel from neuronunit.optimization import get_neab dtc.model_path = get_neab.LEMS_MODEL_PATH dtc.LEMS_MODEL_PATH = get_neab.LEMS_MODEL_PATH model = ReducedModel(dtc.LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') model.set_attrs(dtc.attrs) dtc.scores = {} dtc.score = {} score = get_neab.tests[0].judge(model, stop_on_error=False, deep_error=True) #if bool(model.get_spike_count() == 1 or model.get_spike_count() == 0) if score.sort_key is not None: dtc.scores[str( get_neab.tests[0])] = 1 - score.sort_key #pd.DataFrame([ ]) dtc.rheobase = score.prediction #assert dtc.rheobase is not None return dtc
def sanity_check_score(pop, td, tests): ''' Used for debugging with fake models ''' dtcpop = update_dtc_pop(pop, td) for dtc in dtcpop: dtc.scores = None dtc.scores = {} for t in tests: for dtc in dtcpop: LEMS_MODEL_PATH = path_params['model_path'] model = ReducedModel(LEMS_MODEL_PATH, name=str('vanilla'), backend='NEURON') model.set_attrs(dtc.attrs) score = t.judge(model) dtc.scores.get(str(t), 1.0) if score.sort_key is not None: dtc.scores[str(t)] = 1 - score.sort_key return dtcpop
def check_current(ampl, dtc): ''' Inputs are an amplitude to test and a virtual model output is an virtual model with an updated dictionary. ''' ampl = float(ampl) import os #from neuronunit.models import reduced from neuronunit.models.reduced import ReducedModel #assert os.path.isfile(dtc.model_path), "%s is not a file" % dtc.model_path model = ReducedModel(dtc.model_path, name='vanilla', backend='NEURON') #print(model) #import pdb; pdb.set_trace() DELAY = 100.0 * pq.ms DURATION = 1000.0 * pq.ms params = { 'injected_square_current': { 'amplitude': 100.0 * pq.pA, 'delay': DELAY, 'duration': DURATION } } if ampl not in dtc.lookup or len(dtc.lookup) == 0: current = params.copy()['injected_square_current'] uc = {'amplitude': ampl} current.update(uc) current = {'injected_square_current': current} dtc.run_number += 1 #import ipyparallel as ipp #model = ipp.Reference('model') model.set_attrs(dtc.attrs) model.name = dtc.attrs model.inject_square_current(current) dtc.previous = ampl n_spikes = model.get_spike_count() dtc.lookup[float(ampl)] = n_spikes #name = str('rheobase {0} parameters {1}'.format(str(current),str(model.params))) if n_spikes == 1: dtc.rheobase = float(ampl) dtc.boolean = True return dtc return dtc if float(ampl) in dtc.lookup: return dtc
def check_current(ampl,dtc): ''' Inputs are an amplitude to test and a virtual model output is an virtual model with an updated dictionary. ''' import copy import os import quantities from neuronunit.models.reduced import ReducedModel import neuronunit LEMS_MODEL_PATH = str(neuronunit.__path__[0])+str('/models/NeuroML2/LEMS_2007One.xml') dtc.model_path = LEMS_MODEL_PATH model = ReducedModel(dtc.model_path,name='vanilla', backend=(str(dtc.backend), {'DTC':dtc})) import copy model.set_attrs(dtc.attrs) DELAY = 100.0*pq.ms DURATION = 1000.0*pq.ms params = {'injected_square_current': {'amplitude':100.0*pq.pA, 'delay':DELAY, 'duration':DURATION}} dtc = copy.copy(dtc) ampl = float(ampl) #print(dtc.lookup) if ampl not in dtc.lookup or len(dtc.lookup) == 0: current = params.copy()['injected_square_current'] uc = {'amplitude':ampl} current.update(uc) current = {'injected_square_current':current} dtc.run_number += 1 model.set_attrs(dtc.attrs) model.inject_square_current(current) dtc.previous = ampl n_spikes = model.get_spike_count() dtc.lookup[float(ampl)] = n_spikes if n_spikes == 1: dtc.rheobase = float(ampl) dtc.boolean = True return dtc return dtc if float(ampl) in dtc.lookup: return dtc