def produce_restingVm(self, **kwargs):
"""
kwargs = { "parameters": dictionary with keys,
"stimparameters": dictionary with keys "type" and "stimlist",
"onmodel": instantiated model }
"""
print("Sim produce_restingVm starting ...")
ec = ExecutiveControl() # only works when in ~/cerebmodels
model = ec.launch_model( parameters = kwargs["parameters"],
stimparameters = kwargs["stimparameters"],
stimloc = kwargs["stimloc"], onmodel = kwargs["onmodel"],
capabilities = {"model": "produce_voltage_response",
"vtest": ProducesElectricalResponse},
mode="capability")
#self.fullfilename # already saved by invoking produce_voltage_response above
#print("Signal Processing ...")
nwbfile = rm.load_nwbfile(model.fullfilename)
orderedepochs = rm.order_all_epochs_for_region(nwbfile=nwbfile, region="soma")
timestamps_over_epochs = [ rm.timestamps_for_epoch( orderedepochs[i] )
for i in range(len(orderedepochs)) ]
data_over_epochs = [ rm.data_for_epoch( orderedepochs[i] )
for i in range(len(orderedepochs)) ]
baseVms = spm.distill_Vm_pre_epoch( timestamps = timestamps_over_epochs,
datavalues = data_over_epochs )
#print("Signal Processing Done.")
setattr(model, "prediction", baseVms)
print("Simulation produce_restingVm Done.")
return model
def produce_inputR(self, roi, **kwargs):
"""
roi, region of interest is a string, i.e, 1 key in chosenmodel.regions
kwargs = { "parameters": dictionary with keys,
"stimparameters": dictionary with keys "type" and "stimlist",
"onmodel": instantiated model }
"""
print("Sim produce_" + roi + "_inputR starting ...")
ec = ExecutiveControl() # only works when in ~/cerebmodels
model = ec.launch_model(parameters=kwargs["parameters"],
stimparameters=kwargs["stimparameters"],
stimloc=kwargs["stimloc"],
onmodel=kwargs["onmodel"],
capabilities={
"model": "produce_voltage_response",
"vtest": ProducesElectricalResponse
},
mode="capability")
nwbfile = rm.load_nwbfile(model.fullfilename)
orderedepochs = rm.order_all_epochs_for_region(nwbfile=nwbfile,
region=roi)
timestamps_over_epochs = [
rm.timestamps_for_epoch(orderedepochs[i])
for i in range(len(orderedepochs))
]
data_over_epochs = [
rm.data_for_epoch(orderedepochs[i])
for i in range(len(orderedepochs))
]
baseVms = spm.distill_baseVm_pre_epoch(
timestamps=timestamps_over_epochs, datavalues=data_over_epochs)
setattr(model, "prediction",
self._compute_inputR(baseVms, kwargs["stimparameters"]))
print("Simulation produce_" + roi + "_inputR Done.")
return model
def simulate():
print "running"
#if modelscales_select.value == "No_Models":
#print modelscales_select.value
#else:
#print modelscales_select.value
print pwd
sys.path.append(pwd) # uncomment only when using executiveViz
ec = ExecutiveControl()
modelscale = models_select.value.split()[0]
modelname = models_select.value.split()[1]
chosenmodel = ec.choose_model(modelscale=modelscale,
modelname=modelname)
parameters = ast.literal_eval(runtime_input.value)
print parameters
print stimulation.value
if stimulation.value == "yes":
stimparameters = ast.literal_eval(stim_type_input.value)
stimparameters.update(
{"stimlist": ast.literal_eval(stim_list_input.value)})
ec.launch_model(parameters=parameters,
onmodel=chosenmodel,
stimparameters=stimparameters,
stimloc=stim_loc_input.value)
#with Profiler() as prof, ResourceProfiler() as rprof:
# ec.launch_model ( parameters=parameters, onmodel=chosenmodel,
# stimparameters=stimparameters, stimloc=stim_loc_input.value )
else:
ec.launch_model(parameters=parameters, onmodel=chosenmodel)
#with Profiler() as prof, ResourceProfiler() as rprof:
# ec.launch_model( parameters=parameters, onmodel=chosenmodel )
#myplot = visualize([prof, rprof])
ec.save_response()
print "done running"
def setUp(self):
self.pwd = os.getcwd()
# Create two files with/without stimulus
#fab = Fabricator() # NOTE: Reader() is an exception for not instantiating
os.chdir(rootwd)
self.chosenmodel = DummyCell()
os.chdir(pwd)
#
self.ec = ExecutiveControl()
#
if os.path.isdir(pwd + os.sep + "responses"):
shutil.rmtree("responses")
#
runtimeparam = {"dt": 0.1, "celsius": 30, "tstop": 200.0, "v_init": 65}
stimparam = {
"type": ["current", "IClamp"],
"stimlist": [{
"amp": 0.5,
"dur": 100.0,
"delay": 10.0
}, {
"amp": 1.0,
"dur": 50.0,
"delay": 10.0 + 100.0
}],
"tstop":
runtimeparam["tstop"]
}
#
# Write for stimulus
self.ec.launch_model(parameters=runtimeparam,
stimparameters=stimparam,
stimloc=self.chosenmodel.cell.soma,
onmodel=self.chosenmodel)
self.ec.save_response()
# Get filename
self.file_stim = fm.show_filenames_with_path(
["responses", "cells", "DummyTest"])
# save for comparison
self.stimulus_for_comparison = numpy.array(
self.ec.recordings["stimulus"])
#
# Write for nostimulus
self.ec.launch_model(parameters=runtimeparam, onmodel=self.chosenmodel)
self.ec.save_response()
# Get filename
self.file_nostim = fm.show_filenames_with_path(
["responses", "cells", "DummyTest"])
for key in self.file_stim:
del self.file_nostim[key]
def generate_prediction(self, model, verbose=False):
"""
Generates resting Vm from soma.
The function is automatically called by sciunit.Test which this test is a child of.
Therefore as part of sciunit generate_prediction is mandatory.
"""
#self.confidence = confidence # set confidence for test 90%, 95% (default), 99%
#
runtimeparam = {
"dt": 0.025,
"celsius": 30,
"tstop": 1000.0,
"v_init": -80.
}
stimparam = {
"type": ["current", "IClamp"],
"stimlist": [{
"amp": 0.006,
"dur": 800.0,
"delay": 100.0
}],
"tstop": runtimeparam["tstop"]
}
ec = ExecutiveControl()
#ec.chosenmodel = model
#ec.chosenmodel.restingVm = \
model = ec.launch_model(parameters=runtimeparam,
stimparameters=stimparam,
stimloc="soma",
onmodel=model,
capabilities={
"model": "produce_restingVm",
"vtest": ProducesSomaRestingVm
},
mode="capability")
#return pq.Quantity( numpy.mean(ec.chosenmodel.prediction), # prediction
# units = self.observation["units"] )
return pq.Quantity(
numpy.mean(model.prediction), # prediction
units=self.observation["units"])
def produce_voltage_response(self, **kwargs):
"""generic/essential model response
**Keyword Arguments:**
kwargs = { "parameters": dictionary with keys,
"stimparameters": None or dictionary with keys "type" and "stimlist",
"onmodel": instantiated model }
"""
#ExecutiveControl.launch_model_raw("cells")
print("Simulation produce_voltage_response starting ...")
ec = ExecutiveControl() # only works when in ~/cerebmodels
model = ec.launch_model( parameters = kwargs["parameters"],
stimparameters = kwargs["stimparameters"],
stimloc = kwargs["stimloc"],
onmodel = kwargs["onmodel"], mode = "raw" )
print("File saving ...")
fullfilename = ec.save_response()
setattr(model, "fullfilename", fullfilename)
print("File saved.")
print("Simulation produce_voltage_response Done.")
return model
def update_global_model(attr, old, new):
menu_list = new.split()
modelscale = menu_list[0] # update global modelscale
modelname = menu_list[1] # update glocal modelname
#print modelscale, modelname
sys.path.append(pwd) # uncomment only when using executiveViz
chosenmodel = ExecutiveControl.choose_model(modelscale=str(modelscale),
modelname=str(modelname))
modeltitle.text = chosenmodel.name
modeldescr.text = chosenmodel.description
modelregions.text = "Potential stimulation sites: " + str(
chosenmodel.regions)
runmodel.disabled = False
def produce_soma_spikeheight(self, **kwargs):
"""
kwargs = { "parameters": dictionary with keys,
"stimparameters": dictionary with keys "type" and "stimlist",
"onmodel": instantiated model }
"""
print("Sim produce_soma_spikeheight starting ...")
ec = ExecutiveControl() # only works when in ~/cerebmodels
model = ec.launch_model(parameters=kwargs["parameters"],
stimparameters=kwargs["stimparameters"],
stimloc=kwargs["stimloc"],
onmodel=kwargs["onmodel"],
capabilities={
"model": "produce_voltage_response",
"vtest": ProducesElectricalResponse
},
mode="capability")
nwbfile = rm.load_nwbfile(model.fullfilename)
orderedepochs = rm.order_all_epochs_for_region(nwbfile=nwbfile,
region="soma v")
timestamps_over_epochs = [
rm.timestamps_for_epoch(orderedepochs[i])
for i in range(len(orderedepochs))
]
data_over_epochs = [
rm.data_for_epoch(orderedepochs[i])
for i in range(len(orderedepochs))
]
baseVm = spm.distill_baseVm_pre_epoch(
timestamps=timestamps_over_epochs, datavalues=data_over_epochs)
try:
peakVms = spm.distill_peakVm_from_spikes(
timestamps=timestamps_over_epochs, datavalues=data_over_epochs)
except:
peakVms = baseVm
setattr(model, "prediction", peakVms[0] - baseVm[0])
print("Simulation produce_soma_spikeheight Done.")
return model
def __init__(self, model, validation_test, alpha=0.05, epsilon=5):
"""
This constructor method initializes the dictionary ``.model``,
validation test ``.validation_test``, level of significance ``.alpha``
and error limit (Epsilon) ``.epsilon``.
Default value for ``.alpha`` is set to 0.05 while value of ``.epsilon`` is set to 5.
"""
self.level_of_significance = alpha
self.epsilon = epsilon
self.modelscale = model["modelscale"]
self.modelname = model["modelname"]
self.validation_test = validation_test
from executive import ExecutiveControl as ec
self.exc = ec()
self.desired_model = ec.choose_model(modelscale=self.modelscale,
modelname=self.modelname)
class SpontaneousFiringTest(sciunit.Test):
"""
This test compares the measured unstimulated firing frequency observed in real animal (in-vitro or in-vivo, depending on the data) generated from neuron against those by the model.
"""
required_capabilities = (ProducesEphysMeasurement,)
score_type = TScore
ec = ExecutiveControl()
def generate_prediction(self, model, confidence=0.95, verbose=False):
"""
Generates resting Vm from soma.
The function is automatically called by sciunit.Test which this test is a child of.
Therefore as part of sciunit generate_prediction is mandatory.
"""
self.confidence = confidence # set confidence for test 90%, 95% (default), 99%
#
runtimeparam = {"dt": 0.025, "celsius": 30, "tstop": 1000.0, "v_init": -80.}
stimparam = {"type": ["current", "IClamp"],
"stimlist": [ {"amp": 0.006, "dur": 800.0, "delay": 100.0} ],
"tstop": runtimeparam["tstop"] }
ec.launch_model( parameters = runtimeparam, stimparameters = stimparam,
stimloc = "soma", onmodel = model,
capabilities = {"model": "produce_restingVm",
"vtest": ProducesEphysMeasurement} )
return pq.Quantity( numpy.mean(model.restingVm) # prediction
units = observation["units"] )
def validate_observation(self, observation, first_try=True):
"""
This function is called automatically by sciunit and
clones it into self.observation
This checks if the experimental_data is of some desired
form or magnitude.
Not exactly this function but a version of this is already
performed by the ValidationTestLibrary.get_validation_test
"""
if ("mean" not in observation or
"margin_of_error" not in observation or
"sample_size" not in observation or
"units" not in observation):
raise sciunit.ObservationError
self.observation["mean"] = pq.Quantity( self.observation["mean"],
units=observation["units"] )
self.observation["margin_of_error"] = pq.Quantity( self.observation["margin_of_error"],
units=observation["units"] )
self.observation["standard_error"] = self.observation["margin_of_error"] / \
self.get_tmultiplier(self.confidence, observation["sample_size"])
@staticmethod
def get_tmultiplier(confidence, n):
return scipy.stats.t.ppf( (1+confidence)/2, n-1 )
def compute_score(self, observation, prediction, verbose=False):
"""
This function like generate_pediction is called automatically by sciunit
which RestingVmTest is a child of. This function must be named compute_score
The prediction processed from "vm_soma" is compared against
the experimental_data to get the binary score; 0 if the
prediction correspond with experiment, else 1.
"""
score = TScore.compute( observation, prediction )
score.description = HtestAboutMeans( observation, prediction, score )
print score.hypotest
return score
def TabModels():
"""available_modelscales = ['cells', 'microcircuit', 'network']
"""
def get_select_menu(menu_type, menu_list):
if menu_type == "modelscales":
title = "Modeling Scale Options"
elif menu_type == "models":
title = "Choose a model name"
elif menu_type == "responses":
title = "Choose a response (file)"
return Select(title=title, value=menu_list[0][0], options=menu_list)
def get_menu_modelscales():
#NOTE: available_modelscale & scale_and_models are global variables
menu = [("None", "None")]
for modelscale in available_modelscales:
# tag the modelscale as first element in the value = modellist
modellist = ' '.join([modelscale] + scale_and_models[modelscale])
menu.append(
(modellist, modelscale)) # tuple (string of models, scale)
return menu
def get_menu_models(modellist):
#NOTE: models_with_filenames is a global variable
menu = [("None", "Below are available models")]
if modellist[1] == "No_Models": #modellist[0]=modelname
menu[0] = (modellist[1], modellist[1].replace("_", " ")
) #tuple (scale, string of models)
else:
for modelname in modellist[1:]:
# tag modelscale & modelname as 1st-two elements in the value
itsvalue = ' '.join([modellist[0], modelname])
menu.append(
(itsvalue, modelname)) # tuple (string of models, scale)
return menu
def update_models_list(attr, old, new):
if new == "No_Models":
menu_list = [''.join(list(new))] # ["No Models"]
else:
menu_list = new.split()
models_select.options = get_menu_models(menu_list)
runmodel.disabled = True
#print new
#print modelscales_select.value
#print menu_list
#print menu_list[0]
def update_global_model(attr, old, new):
menu_list = new.split()
modelscale = menu_list[0] # update global modelscale
modelname = menu_list[1] # update glocal modelname
#print modelscale, modelname
sys.path.append(pwd) # uncomment only when using executiveViz
chosenmodel = ExecutiveControl.choose_model(modelscale=str(modelscale),
modelname=str(modelname))
modeltitle.text = chosenmodel.name
modeldescr.text = chosenmodel.description
modelregions.text = "Potential stimulation sites: " + str(
chosenmodel.regions)
runmodel.disabled = False
def update_stimulation_parameters_input_status(attr, old, new):
if new == "no":
stim_type_input.disabled = True
stim_list_input.disabled = True
stim_loc_input.disabled = True
else:
stim_type_input.disabled = False
stim_list_input.disabled = False
stim_loc_input.disabled = False
def clicked():
print "clicked"
def simulate():
print "running"
#if modelscales_select.value == "No_Models":
#print modelscales_select.value
#else:
#print modelscales_select.value
print pwd
sys.path.append(pwd) # uncomment only when using executiveViz
ec = ExecutiveControl()
modelscale = models_select.value.split()[0]
modelname = models_select.value.split()[1]
chosenmodel = ec.choose_model(modelscale=modelscale,
modelname=modelname)
parameters = ast.literal_eval(runtime_input.value)
print parameters
print stimulation.value
if stimulation.value == "yes":
stimparameters = ast.literal_eval(stim_type_input.value)
stimparameters.update(
{"stimlist": ast.literal_eval(stim_list_input.value)})
ec.launch_model(parameters=parameters,
onmodel=chosenmodel,
stimparameters=stimparameters,
stimloc=stim_loc_input.value)
#with Profiler() as prof, ResourceProfiler() as rprof:
# ec.launch_model ( parameters=parameters, onmodel=chosenmodel,
# stimparameters=stimparameters, stimloc=stim_loc_input.value )
else:
ec.launch_model(parameters=parameters, onmodel=chosenmodel)
#with Profiler() as prof, ResourceProfiler() as rprof:
# ec.launch_model( parameters=parameters, onmodel=chosenmodel )
#myplot = visualize([prof, rprof])
ec.save_response()
print "done running"
#viz_source.data['diagnostic'][0] = prof
#viz_source.data['diagnostic'][1] = rprof
#viz_source.data['diagnostic'] = [prof, rprof]
#viz_source.data['diagnostic'][0].results[0] = prof.results[0]
#myplot.data['diagplots'][0] = visualize([prof, rprof])
#return visualize([prof, rprof])
#
### +++++++++++++++++++GENERATE DATA FOR THE OPTIONS MENU++++++++++++++++++
# available_modelscales -- list
# scale_and_models -- dictionary with list as key value
# models_with_filenames -- dictionary with list as key value
# responses_with_filepaths -- dictionary with string as key value
# Generate Model Info
#os.chdir("..") # line required for calling ~/managers/bokehtest.py
#available_modelscales = fm.available_modelscales()
#os.chdir(rootwd) # for running it from ~/managers
available_modelscales = ExecutiveControl.list_modelscales()
scale_and_models = {}
for modelscale in available_modelscales: # get list of models in each scale
try:
#modelslist = fm.modelscale_inventory(model_scale=modelscale)
modelslist = ExecutiveControl.list_models(modelscale=modelscale)
except:
modelslist = ["No_Models"]
scale_and_models.update({modelscale: modelslist})
#os.chdir(pwd) # for running it from ~/managers
#print scale_and_models
### ++++++++++++++++++++END GENERATE DATA FOR THE OPTIONS++++++++++++++++++
#
modelscale = None
modelname = None
chosenmodel = None
#
menu = get_menu_modelscales()
modelscales_select = get_select_menu("modelscales", menu)
#
dummy_model_menu = [('None', "First select a model scale")]
models_select = get_select_menu("models", dummy_model_menu)
#
runtime_input = TextInput(
value="{'dt': 0.1, 'celsius': 30, 'tstop': 10, 'v_init': 65}",
title="Runtime Parameters:")
#print runtime_input.value
#print type(runtime_input.value)
#
stimulation_menu = [("No", "no"), None, ("Yes", "yes")]
stimulation = Dropdown(label="Stimulation Yes/No",
button_type="warning",
menu=stimulation_menu)
stim_type_input = TextInput(
value="{'type': ['current', 'IClamp']}",
title="Stimulation Parameters (Stimulation Type):")
stim_list_input = TextInput(
value="[{'amp': 0.5, 'dur': 10.0, 'delay': 5.0}, "
" {'amp': 1.0, 'dur': 20.0, 'delay': 15.0}]",
title="Stimulation Parameters (Stimuli):")
stim_loc_input = TextInput(value='soma', title="Stimulation location:")
# disable stimulation by DEFAULT
stim_type_input.disabled = True
stim_list_input.disabled = True
stim_loc_input.disabled = True
#
runmodel = Button(label="Run Simulation", button_type="success")
runmodel.disabled = True
#
modeltitle = Div(text="""No Model has been selected yet.""",
width=290,
height=40)
modeldescr = Paragraph(text="""There is no Model Description.""",
width=290,
height=200)
modelregions = Div(
text="""Main Locations within the model for stimulation""",
width=290,
height=50)
# disable the model texts by DEFAULT
modeltitle.disabled = True
modeldescr.disabled = True
modelregions.disabled = True
def viz():
return visualize(viz_source.data['diagnostic'])
# Put controls in a single element
viz_source = ColumnDataSource(
data={'diagnostic': [Profiler(), ResourceProfiler()]})
myplot = viz()
#diagplot = visualize( viz_source.data['diagnostic'] )
#myplot = ColumnDataSource(data={'diagplots': [diagplot]})
#myplot = ColumnDataSource(data={'diagplots': [visualize([Profiler(), ResourceProfiler()])]})
# INTERACTION
modelscales_select.on_change("value", update_models_list)
models_select.on_change("value", update_global_model)
#responses_select.on_change("value", update_plot)
stimulation.on_change("value", update_stimulation_parameters_input_status)
runmodel.on_click(simulate)
# Create a row layout
mylayout = row(
WidgetBox(modelscales_select, models_select, runtime_input,
stimulation, stim_type_input, stim_list_input,
stim_loc_input, runmodel),
WidgetBox(modeltitle, modeldescr, modelregions),
#row(viz_source.data['diagnostic'][0].visualize()))
#row(myplot.data['diagplots'][0]))
row(myplot))
# Make a tab with the layout
tab = Panel(child=mylayout, title='Choose Model')
return tab
class ReaderTest(unittest.TestCase):
def setUp(self):
self.pwd = os.getcwd()
# Create two files with/without stimulus
#fab = Fabricator() # NOTE: Reader() is an exception for not instantiating
os.chdir(rootwd)
self.chosenmodel = DummyCell()
os.chdir(pwd)
#
self.ec = ExecutiveControl()
#
if os.path.isdir(pwd + os.sep + "responses"):
shutil.rmtree("responses")
#
runtimeparam = {"dt": 0.1, "celsius": 30, "tstop": 200.0, "v_init": 65}
stimparam = {
"type": ["current", "IClamp"],
"stimlist": [{
"amp": 0.5,
"dur": 100.0,
"delay": 10.0
}, {
"amp": 1.0,
"dur": 50.0,
"delay": 10.0 + 100.0
}],
"tstop":
runtimeparam["tstop"]
}
#
# Write for stimulus
self.ec.launch_model(parameters=runtimeparam,
stimparameters=stimparam,
stimloc=self.chosenmodel.cell.soma,
onmodel=self.chosenmodel)
self.ec.save_response()
# Get filename
self.file_stim = fm.show_filenames_with_path(
["responses", "cells", "DummyTest"])
# save for comparison
self.stimulus_for_comparison = numpy.array(
self.ec.recordings["stimulus"])
#
# Write for nostimulus
self.ec.launch_model(parameters=runtimeparam, onmodel=self.chosenmodel)
self.ec.save_response()
# Get filename
self.file_nostim = fm.show_filenames_with_path(
["responses", "cells", "DummyTest"])
for key in self.file_stim:
del self.file_nostim[key]
#@unittest.skip("reason for skipping")
def test_1_init(self):
# loads nwbfile, extracts modelname, modelscale & instantiate model
os.chdir(rootwd)
for key in self.file_nostim:
reader_io_nostim = Reader(self.file_nostim[key])
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
#
reader_io_nostim.chosenmodel = self.chosenmodel
reader_io_stim.chosenmodel = self.chosenmodel
#print self.chosenmodel.name
# this tests extract_modelname_modelscale & load_model
compare1 = [
reader_io_nostim.modelname, # output of
reader_io_nostim.modelscale
] # extract_modelname_modelscale()
compare2 = [
reader_io_stim.chosenmodel.modelname, # output of
reader_io_stim.chosenmodel.modelscale
] # load_model()
self.assertEqual(compare1, compare2)
reader_io_nostim.closefile()
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_2_visualizetable(self):
# gives you session of the nwbfile
os.chdir(rootwd)
for key in self.file_nostim:
reader_io_nostim = Reader(self.file_nostim[key])
os.chdir(pwd)
reader_io_nostim.session_info() # pretty prints table
reader_io_nostim.closefile()
#@unittest.skip("reason for skipping")
def test_3_pull_epochindices_chosenregion(self):
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
epoch_indices_soma = reader_io_stim.pull_epochindices_chosenregion(
'soma')
epoch_indices_axon = reader_io_stim.pull_epochindices_chosenregion(
'axon')
#print epoch_indices_soma
#print epoch_indices_axon
self.assertNotEqual(epoch_indices_soma, epoch_indices_axon)
reader_io_stim.closefile()
#shutil.rmtree("responses")
#@unittest.skip("reason for skipping")
def test_4_pull_epochid(self):
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
epoch_indices_soma = reader_io_stim.pull_epochindices_chosenregion(
'soma')
epoch_indices_axon = reader_io_stim.pull_epochindices_chosenregion(
'axon')
epoch_ids_soma = [
reader_io_stim.pull_epochid(epoch_indices_soma[0]),
reader_io_stim.pull_epochid(epoch_indices_soma[1]),
reader_io_stim.pull_epochid(epoch_indices_soma[2]),
reader_io_stim.pull_epochid(epoch_indices_soma[3])
]
epoch_ids_axon = [
reader_io_stim.pull_epochid(epoch_indices_axon[0]),
reader_io_stim.pull_epochid(epoch_indices_axon[1]),
reader_io_stim.pull_epochid(epoch_indices_axon[2]),
reader_io_stim.pull_epochid(epoch_indices_axon[3])
]
#print epoch_indices_soma
#print epoch_indices_axon
#print epoch_ids_soma
#print epoch_ids_axon
#print len(reader_io_stim.nwbfile.epochs.epochs.data)
#print reader_io_stim.nwbfile.epochs.epochs.data[0]#[3][0]
#print reader_io_stim.nwbfile.epochs.epochs.data[3]#[3][0]
#print reader_io_stim.nwbfile.epochs.epochs.data[4]#[3][0]
#print reader_io_stim.nwbfile.epochs.epochs.data[5]#[3][0]
#print epoch_indices_soma, epoch_id_soma
#print epoch_indices_soma, reader_io_stimulus.pull_epochid(epoch_indices_soma[1])
#print epoch_indices_axon, epoch_id_axon
#print reader_io_stimulus.nwbfile.epochs.epochs.data
#print reader_io_stimulus.nwbfile.epochs.epochs.data[0]
#print reader_io_stimulus.nwbfile.epochs.epochs.data[1][2]
self.assertNotEqual(epoch_ids_soma, epoch_ids_axon)
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_5_drawout_orderedepochs(self):
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
orderedepochs_soma = reader_io_stim.drawout_orderedepochs('soma')
#print orderedepochs_soma
#print len(orderedepochs_soma)
#print orderedepochs_soma[0] # first, i.e, epoch
#print orderedepochs_soma[0][2] # get root tuple
#print orderedepochs_soma[0][2][3] # get array
#print orderedepochs_soma[0][2][3][0] # take out tuple from the array
#print orderedepochs_soma[0][2][3][0][2] # take out timeseries object from tuple
#print orderedepochs_soma[0][2][3][0][2].data.value
#print type(orderedepochs_soma[0][2][3][0][2].data.value)
#print orderedepochs_soma[0][2][3][0][2].timestamps.value
#print len([ orderedepochs_soma[0][2][3][0][2].timestamps.value[i]
# for i in numpy.arange(orderedepochs_soma[0][2][3][0][0],
# orderedepochs_soma[0][2][3][0][1]) ])
#print orderedepochs_soma[0][1]
#print orderedepochs_soma[0][0]
#print reader_io_stim.nwbfile.epochs.epochs.data[orderedepochs_soma[0][0]]
#to compare
compare1 = [orderedepochs_soma[0][1], orderedepochs_soma[1][1]]
self.assertEqual(compare1, [0, 1])
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_6_get_tuple_for_epoch(self):
# To get an epoch
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
orderedepochs_soma = reader_io_stim.drawout_orderedepochs(
'soma') # drawout orderedepochs
#epochs = []
#for i in range(len(orderedepochs_soma)):
# epoch_id = orderedepochs_soma[i][1]
# epochs.append( Reader.get_array_for_epoch(epoch_id, orderedepochs_soma) ) # get epoch
#print epochs
#print epochs[0]
#print epochs[1]
epoch_id = 0
epochtuple = Reader.get_tuple_for_epoch(epoch_id, orderedepochs_soma)
#print epochtuple
#print epochtuple[2].timestamps_unit #description/unit/time_unit/timestamps_unit
self.assertNotEqual(
epochtuple[0], # tstart index
epochtuple[1]) # counts
#self.assertNotEqual( epochs[0], epochs[1] )
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_7_get_timestamps_for_epoch(self):
os.chdir(rootwd)
for key in self.file_nostim:
reader_io_nostim = Reader(self.file_nostim[key])
os.chdir(pwd)
orderedepochs_soma = reader_io_nostim.drawout_orderedepochs(
'soma') #drawout orderedepoch
orderedepochs_axon = reader_io_nostim.drawout_orderedepochs('axon')
epoch_id = 0
times_soma = reader_io_nostim.get_timestamps_for_epoch(
epoch_id, orderedepochs_soma)
times_axon = reader_io_nostim.get_timestamps_for_epoch(
epoch_id, orderedepochs_axon)
#
self.assertEqual([len(times_soma), times_soma],
[len(times_axon), times_axon])
reader_io_nostim.closefile()
#@unittest.skip("reason for skipping")
def test_8_get_datavalues_for_epoch(self):
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
orderedepochs_soma = reader_io_stim.drawout_orderedepochs(
'soma') #drawout orderedepoch
orderedepochs_axon = reader_io_stim.drawout_orderedepochs('axon')
epoch_id = 1
data_soma = reader_io_stim.get_datavalues_for_epoch(
epoch_id, orderedepochs_soma)
data_axon = reader_io_stim.get_datavalues_for_epoch(
epoch_id, orderedepochs_axon)
#
self.assertNotEqual(data_soma, data_axon)
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_9_get_stimulus(self):
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
#print help(reader_io_stim.nwbfile)
#print reader_io_stim.nwbfile.get_stimulus["DummyTest_stimulus"]
#print help(reader_io_stim.nwbfile)
#print reader_io_stim.nwbfile.acquisition
#print reader_io_stim.nwbfile.stimulus
#print reader_io_stim.nwbfile
#
#print reader_io_stim.nwbfile.stimulus
#print reader_io_stim.nwbfile.stimulus["DummyTest_stimulus"]
#print reader_io_stim.nwbfile.stimulus["DummyTest_stimulus"].data
#print reader_io_stim.nwbfile.stimulus["DummyTest_stimulus"].data.value
reader_io_stim.chosenmodel = self.chosenmodel
stimulus = reader_io_stim.get_stimulus()
#print stimulus
#print stimulus.data
#print stimulus.timestamps
a = all(
boolean == True
for boolean in stimulus.data.value == self.stimulus_for_comparison)
self.assertTrue(a is True)
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_x_get_stimulus(self):
os.chdir(rootwd)
for key in self.file_nostim:
reader_io_nostim = Reader(self.file_nostim[key])
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
reader_io_stim.chosenmodel = self.chosenmodel
stimulus = reader_io_stim.get_stimulus()
timestamps = reader_io_nostim.get_timestamps()
#print stimulus
#print stimulus.data
#print stimulus.timestamps.value
#print timestamps.value
#print help(timestamps)
a = all(boolean == True
for boolean in stimulus.timestamps.value == timestamps.value)
self.assertTrue(a is True)
reader_io_stim.closefile()
#@unittest.skip("reason for skipping")
def test_xi_get_description_epoch(self):
#print "test XI"
os.chdir(rootwd)
for key in self.file_stim:
reader_io_stim = Reader(self.file_stim[key])
os.chdir(pwd)
orderedepochs_soma = reader_io_stim.drawout_orderedepochs(
'soma') #drawout ordered epoch
descrip_0soma = Reader.get_description_epoch(
0, orderedepochs_soma) # get epoch
descrip_1soma = Reader.get_description_epoch(1, orderedepochs_soma)
#
#print descrip_0soma
#print descrip_1soma
self.assertNotEqual(descrip_0soma, descrip_1soma)
reader_io_stim.closefile()
shutil.rmtree("responses")
def setUp(self):
self.ec = ExecutiveControl(
) #instance for non: static & class methods.
self.pwd = os.getcwd()
class ExecutiveControlTest(unittest.TestCase):
def setUp(self):
self.ec = ExecutiveControl(
) #instance for non: static & class methods.
self.pwd = os.getcwd()
#@unittest.skip("reason for skipping")
def test_1_list_modelscales(self):
x = len(self.ec.list_modelscales()) != 0
self.assertEqual(x, True)
#@unittest.skip("reason for skipping")
def test_2_list_models(self):
dummyscale_path = self.pwd + os.sep + "models" + os.sep + "dummyscale"
for i in range(3): # create three dummymodels
os.makedirs(dummyscale_path + os.sep + "dummymodel" + str(i + 1))
self.assertEqual(len(self.ec.list_models(modelscale="dummyscale")), 3)
shutil.rmtree(dummyscale_path)
#@unittest.skip("reason for skipping")
def test_3_choose_model(self):
# NOTE: this only works if the 'minimal' script
# ~/models/cells/model2015Masoli.py exists
# 'minimal' => a class with __init__ method with
# self.modelname = "PC2015Masoli.py"
x = self.ec.choose_model(modelscale="cells",
modelname="PC2015Masoli") #"DummyTest"
self.assertEqual(x.modelname, "PC2015Masoli")
#@unittest.skip("reason for skipping")
def test_4_launch_model_NEURON_nostimulus_with_capability(self):
pickedmodel = self.ec.choose_model(modelscale="cells",
modelname="DummyTest")
parameters = {"dt": 0.01, "celsius": 30, "tstop": 100, "v_init": 65}
self.assertEqual(
self.ec.launch_model(parameters=parameters,
onmodel=pickedmodel,
capabilities={
'model': None,
'vtest': None
}), pickedmodel)
@unittest.skip("reason for skipping")
def test_5_launch_model_NEURON_nostimulus_raw(self):
pickedmodel = self.ec.choose_model(modelscale="cells",
modelname="PC2015Masoli")
parameters = {"dt": 0.1, "celsius": 30, "tstop": 10, "v_init": 65}
self.assertEqual(
self.ec.launch_model(parameters=parameters, onmodel=pickedmodel),
pickedmodel)
@unittest.skip("reason for skipping")
def test_6_save_response(self):
pickedmodel = self.ec.choose_model(modelscale="cells",
modelname="PC2015Masoli")
parameters = {"dt": 0.1, "celsius": 30, "tstop": 10, "v_init": 65}
stimparameters = {
"type": ["current", "IClamp"],
"stimlist": [{
"amp": 0.5,
"dur": 5.0,
"delay": 1.0
}, {
"amp": 1.0,
"dur": 5.0,
"delay": 0.0 + 5.0
}],
"tstop":
parameters["tstop"]
}
model = self.ec.launch_model(parameters=parameters,
onmodel=pickedmodel,
stimparameters=stimparameters,
stimloc="soma")
fullfilename = self.ec.save_response()
#
sesstime = str(self.ec.tm.nwbfile.session_start_time).replace(
" ", "_")[0:-6]
filename_shouldbe = self.ec.tm.nwbfile.session_id + "_" + sesstime.replace(
":", "-") + ".h5"
#
path = os.getcwd(
) + os.sep + "responses" + os.sep + model.modelscale + os.sep + model.modelname
shutil.rmtree(path)
#
fullname_shouldbe = path + os.sep + filename_shouldbe
#
self.assertEqual(fullfilename, fullname_shouldbe)
