class RunSimulate(object):
_log = logging.getLogger('allensdk.model.biophysical.run_simulate')
def __init__(self, input_json, output_json):
self.input_json = input_json
self.output_json = output_json
self.app_config = None
self.manifest = None
def load_manifest(self):
self.app_config = Config().load(self.input_json)
self.manifest = self.app_config.manifest
fix_sections = ['passive', 'axon_morph,', 'conditions', 'fitting']
self.app_config.fix_unary_sections(fix_sections)
def nrnivmodl(self):
RunSimulate._log.debug("nrnivmodl")
subprocess.call(['nrnivmodl', './modfiles'])
def simulate(self):
from allensdk.internal.api.queries.biophysical_module_reader \
import BiophysicalModuleReader
self.load_manifest()
try:
stimulus_path = self.manifest.get_path('stimulus_path')
RunSimulate._log.info("stimulus path: %s" % (stimulus_path))
except:
raise Exception(
'Could not read input stimulus path from input config.')
try:
out_path = self.manifest.get_path('output_path')
RunSimulate._log.info("result NWB file: %s" % (out_path))
except:
raise Exception('Could not read output path from input config.')
try:
morphology_path = self.manifest.get_path('MORPHOLOGY')
RunSimulate._log.info("morphology path: %s" % (morphology_path))
except:
raise Exception(
'Could not read morphology path from input config.')
single_cell.run(self.app_config)
lims_upload_config = BiophysicalModuleReader()
lims_upload_config.read_json(
self.manifest.get_path('neuronal_model_run_data'))
lims_upload_config.update_well_known_file(out_path)
lims_upload_config.set_workflow_state('passed')
lims_upload_config.write_file(self.output_json)
def main(limit, manifest_path):
app_config = Config()
description = app_config.load(manifest_path)
if 'LOG_CFG' in os.environ:
log_config = os.environ['LOG_CFG']
else:
log_config = resource_filename('allensdk.model.biophysical',
'logging.conf')
os.environ['LOG_CFG'] = log_config
lc.fileConfig(log_config)
run_passive_fit(description)
def main():
import sys
manifest_path = sys.argv[-1]
limit = float(sys.argv[-2])
os.chdir(os.path.dirname(manifest_path))
app_config = Config()
description = app_config.load(manifest_path)
upfile = description.manifest.get_path('upfile')
up_data = np.loadtxt(upfile)
downfile = description.manifest.get_path('downfile')
down_data = np.loadtxt(downfile)
swc_path = description.manifest.get_path('MORPHOLOGY')
output_file = description.manifest.get_path('fit_2_file')
data = neuron_passive_fit2(up_data, down_data, swc_path, limit)
json_utilities.write(output_file, data)
def choose_bps_command(command='bps_simple', conf_file=None):
log = logging.getLogger('allensdk.model.biophys_sim.bps_command')
log.info("bps command: %s" % (command))
if conf_file:
conf_file = os.path.abspath(conf_file)
if command == 'help':
print Config().argparser.parse_args(['--help'])
elif command == 'nrnivmodl':
sp.call(['nrnivmodl', 'modfiles']) # TODO: alternate location in manifest?
elif command == 'run_simple':
app_config = Config()
description = app_config.load(conf_file)
sys.path.insert(1, description.manifest.get_path('CODE_DIR'))
(module_name, function_name) = description.data['runs'][0]['main'].split('#')
run_module(description, module_name, function_name)
else:
raise Exception("unknown command %s" %(command))
def load_description(manifest_json_path):
'''Read configuration file.
Parameters
----------
manifest_json_path : string
File containing the experiment configuration.
Returns
-------
Config
Object with all information needed to run the experiment.
'''
description = Config().load(manifest_json_path)
# fix nonstandard description sections
fix_sections = ['passive', 'axon_morph,', 'conditions', 'fitting']
description.fix_unary_sections(fix_sections)
return description
def load_description(manifest_json_path):
'''Read configuration file.
Parameters
----------
manifest_json_path : string
File containing the experiment configuration.
Returns
-------
Config
Object with all information needed to run the experiment.
'''
description = Config().load(manifest_json_path)
# fix nonstandard description sections
fix_sections = ['passive', 'axon_morph,', 'conditions', 'fitting']
description.fix_unary_sections(fix_sections)
return description
def choose_bps_command(command='bps_simple', conf_file=None):
log = logging.getLogger('allensdk.model.biophys_sim.bps_command')
log.info("bps command: %s" % (command))
if conf_file:
conf_file = os.path.abspath(conf_file)
if command == 'help':
print(Config().argparser.parse_args(['--help']))
elif command == 'nrnivmodl':
sp.call(['nrnivmodl', 'modfiles'])
elif command == 'run_simple':
app_config = Config()
description = app_config.load(conf_file)
sys.path.insert(1, description.manifest.get_path('CODE_DIR'))
(module_name,
function_name) = description.data['runs'][0]['main'].split('#')
run_module(description, module_name, function_name)
else:
raise Exception("unknown command %s" % (command))
def simple_config():
manifest = '''{
"manifest": [
{ "type": "dir",
"spec": "MOCK_DOT",
"key": "BASEDIR"
}],
"biophys":
[{ "hoc": [ "stdgui.hoc"] }]
}'''
with patch(builtins.__name__ + ".open", mock_open(read_data=manifest)):
config = Config().load('config.json', False)
return config
def simple_config():
manifest = {
'manifest': [{
'type': 'dir',
'spec': 'MOCK_DOT',
'key': 'BASEDIR'
}],
'biophys': [{
'hoc': ['stdgui.hoc']
}],
}
ju = JsonComments
ju.read_file = MagicMock(return_value=manifest)
config = Config().load('config.json', False)
return config
def init_model(self):
'''
Retrieves the model information for self.model_id, and initializes the modeling and visualization data.
'''
# Retrieve the model data
try:
self.bp.cache_data(self.model_id, working_directory=self.model_dir)
except:
print "Could not access biophysical data for model " + str(
self.model_id)
print "Please confirm model ID and try again."
quit()
# Compile the mod files for the current model
curr_dir = os.getcwd()
os.chdir(self.model_dir)
self.__compile_modfiles()
# set up the NEURON environment using the manifest file
description = Config().load('manifest.json')
# Specify model type (perisomatic/all-active)
currType = description.data['biophys'][0]['model_type']
# initialize the Hoc interpreter we'll use to affect the model
utils = create_utils(description, model_type=currType)
# configure the model for NEURON
morphologyLoc = description.manifest.get_path('MORPHOLOGY')
utils.generate_morphology(morphologyLoc.encode('ascii', 'ignore'))
utils.load_cell_parameters()
# store the hoc interpreter and cell information in the object instance
self.h = utils.h
self.utils = utils
self.description = description
# set up a monitor to log simulation time
self.section_output["t"] = self.h.Vector()
self.section_output["t"].record(self.h._ref_t)
# return to the previous directory
os.chdir(curr_dir)
def test_biophysical():
neuronal_model_id = 472451419 # get this from the web site
model_directory = '.'
bp = BiophysicalApi('http://api.brain-map.org')
bp.cache_stimulus = False # don't want to download the large stimulus NWB file
bp.cache_data(neuronal_model_id, working_directory=model_directory)
os.system('nrnivmodl modfiles')
description = Config().load('manifest.json')
utils = Utils(description)
h = utils.h
manifest = description.manifest
morphology_path = manifest.get_path('MORPHOLOGY')
utils.generate_morphology(morphology_path.encode('ascii', 'ignore'))
utils.load_cell_parameters()
stim = h.IClamp(h.soma[0](0.5))
stim.amp = 0.18
stim.delay = 1000.0
stim.dur = 1000.0
h.tstop = 3000.0
vec = utils.record_values()
h.finitialize()
h.run()
output_path = 'output_voltage.dat'
junction_potential = description.data['fitting'][0]['junction_potential']
mV = 1.0e-3
ms = 1.0e-3
output_data = (numpy.array(vec['v']) - junction_potential) * mV
output_times = numpy.array(vec['t']) * ms
DatUtilities.save_voltage(output_path, output_data, output_times)
assert numpy.count_nonzero(output_data) > 0
def test_biophysical_peri():
"""
Test for backward compatibility of the perisomatic models
"""
subprocess.check_call(['nrnivmodl', 'modfiles/'])
description = Config().load('manifest.json')
utils = Utils(description)
h = utils.h
manifest = description.manifest
morphology_path = manifest.get_path('MORPHOLOGY')
utils.generate_morphology(
morphology_path.encode('ascii', 'ignore').decode("utf-8"))
utils.load_cell_parameters()
stim = h.IClamp(h.soma[0](0.5))
stim.amp = 0.35 # Sweep 47
stim.delay = 1000.0
stim.dur = 1000.0
h.tstop = 3000.0
vec = utils.record_values()
h.finitialize()
h.run()
junction_potential = description.data['fitting'][0]['junction_potential']
ms = 1.0e-3
output_data = (numpy.array(vec['v']) - junction_potential) # in mV
output_times = numpy.array(vec['t']) * ms # in s
output_path = 'output_voltage.dat'
DatUtilities.save_voltage(output_path, output_data, output_times)
num_spikes = len(
ephys_features.detect_putative_spikes(output_data, output_times))
assert num_spikes == 27 # taken from the web app
def test_simulate(hoc_init, mock_h, run_simulate):
# import allensdk.eclipse_debug
mock_utils = Mock(name='mock_utils', h=mock_h)
with patch(
'allensdk.internal.api.queries.biophysical_module_reader.BiophysicalModuleReader',
MagicMock(name="bio_mod_reader")) as bio_mod_reader:
with patch('allensdk.model.biophysical.runner.save_nwb',
MagicMock(name="save_nwb")) as save_nwb:
with patch('allensdk.model.biophysical.runner.NwbDataSet',
MagicMock(name='nwb_data_set')) as nwb_data_set:
with patch('allensdk.model.biophysical.runner.copy',
MagicMock(name='shutil_copy')) as cp:
with patch('allensdk.model.biophysical.utils.create_utils',
return_value=mock_utils) as cu:
with patch(builtins.__name__ + ".open",
mock_open(read_data=MANIFEST_JSON)):
fit_description = Config().load('manifest.json')
Utils.description = fit_description
run_simulate.simulate()
def AllenCell(path=None):
owd = os.getcwd()
os.chdir(path)
# sys.path.append('/home/craig_kelley_downstate_edu/allensdk/lib/python3.6/site-packages/')
from allensdk.model.biophys_sim.config import Config
from allensdk.model.biophysical import utils as Utils # this is basically "implied" in the tutorial
description = Config().load('manifest.json')
manifest = description.manifest
morphology_path = description.manifest.get_path('MORPHOLOGY')
utils = Utils.create_utils(
description, model_type='Biophysical - all active'
) # this is insane - help doc says ALL_ACTIVE_TYPE or PERISOMATIC_TYPE for model_type
h = utils.h
utils.generate_morphology(
morphology_path
) # in tutorial, they instead use mophology_path.encode('ascii','ignore')
utils.load_cell_parameters()
cell = allenCell()
cell.generate_cell(h)
os.chdir(owd)
return cell
def run_nrn(manifest, current, t_start, t_stop):
description = Config().load(manifest)
description.update_data({'axon_type': 'truncated'}, 'biophys')
fix_sections = ['passive', 'axon_morph,', 'conditions', 'fitting']
description.fix_unary_sections(fix_sections)
utils = create_utils(description)
hoc = utils.h
manifest = description.manifest
morphology_path = manifest.get_path('MORPHOLOGY').encode(
'ascii', 'ignore').decode("utf-8")
stimulus_path = description.manifest.get_path('stimulus_path')
utils.generate_morphology(morphology_path)
utils.load_cell_parameters()
utils.read_stimulus(stimulus_path, sweep=35) # needed for sampling rates
stim = hoc.IClamp(hoc.soma[0](0.5))
stim.amp = current
stim.delay = t_start
stim.dur = t_stop - t_start
simulation_dt = 1.0e3 / utils.simulation_sampling_rate
hoc.dt = simulation_dt
hoc.tstop = t_start + t_stop
vec = utils.record_values()
hoc.finitialize()
hoc.run()
recorded_data = utils.get_recorded_data(vec)
vs = recorded_data['v']
ts = recorded_data['t']
return ts, vs
def load_manifest(self):
self.app_config = Config().load(self.input_json)
self.manifest = self.app_config.manifest
self.data_set = NwbDataSet(self.manifest.get_path('stimulus_path'))
def run_simulation(config_f_name):
h('starttime = startsw()')
config = Config().load(config_f_name) # read configuration for the model
utils_obj = Utils(config) # Instantiate an object of a class Utils which configures NEURON and provides the interface to the necessary functions to set up the simulation.
cells_db = utils_obj.load_cell_db() # Load the information about individual cells.
utils_obj.set_run_params() # set h.dt and h.tsop
workdir_n = str(utils_obj.description.data['biophys'][0]['output_dir'])
if (int(pc.id()) == 0):
if not os.path.exists(workdir_n):
os.mkdir(workdir_n)
print 'Workdir: %s.' % workdir_n
print ''
pc.barrier() # Wait for all hosts to get to this point
instantiate_cells_and_cell_types(cells_db)
mkcells(cells_db, utils_obj)
pc.barrier()
utils_obj.load_syn_data() # Load synaptic parameters (for types of sources and targets).
pc.barrier()
if ('connections' in utils_obj.description.data.keys()):
con_path = utils_obj.description.data['connections']
connectcells(con_path, cells_db, utils_obj)
pc.barrier()
# Go over all source of external inputs and instantiate them for the appropriate cells.
for ext_inp_path in reversed(utils_obj.description.data['ext_inputs'].keys()):
if not os.path.exists(ext_inp_path):
print "Error: the external inputs file %s does not exist; exiting." % (ext_inp_path)
h.finish()
ext_inp_map = pd.read_csv(utils_obj.description.data['ext_inputs'][ext_inp_path]['map'], sep=' ')
for tar_gid in cells:
if pc.gid_exists(tar_gid):
tar_ext_inp_map = ext_inp_map[ext_inp_map['index'] == tar_gid]
external_inputs(tar_gid, ext_inp_path, tar_ext_inp_map, utils_obj.description.data['ext_inputs'][ext_inp_path], h.tstop, utils_obj)
pc.barrier() # wait for all hosts to get to this point
h.load_file('mkstim_SEClamp.hoc')
SEClamp_gids = []
if (utils_obj.description.data['cell_data_tracking']['SEClamp_insert'] == 'yes'):
SEClamp_insert_first_cell = utils_obj.description.data['cell_data_tracking']['SEClamp_insert_first_cell']
for gid in cells:
if ((gid >= SEClamp_insert_first_cell) and ((gid - SEClamp_insert_first_cell) % utils_obj.description.data['cell_data_tracking']['SEClamp_insert_cell_gid_step'] == 0) and ( cell_types[type_index(gid)] not in ['LIF_exc', 'LIF_inh'])):
tmp_line = str(pc.gid2cell(gid).hname()) + '.soma[0]'
h.mkstim_SEClamp(tmp_line, 0.5, -70.0, h.tstop)
SEClamp_gids.append(gid)
pc.barrier() # wait for all hosts to get to this point
h.load_file("save_t_series.hoc")
save_value_ID_list = []
k = 0
if (utils_obj.description.data['cell_data_tracking']['do_save_t_series'] == 'yes'):
for cell_gid in cells:
if ((cell_gid % utils_obj.description.data['cell_data_tracking']['id_step_save_t_series'] == 0) and (cell_types[type_index(cell_gid)] not in ['LIF_exc', 'LIF_inh'])):
save_value = str(pc.gid2cell(cell_gid).hname()) + '.soma[0].v(0)'
save_value_ID_list.append(k)
k += 1
h.save_t_series_prep(save_value)
pc.barrier() # wait for all hosts to get to this point
h.load_file("spikefile.hoc")
h.record_spikes(cell_displ[-1])
pc.barrier() # wait for all hosts to get to this point
pc.timeout(0)
#h.cvode.debug_event(1)
h.load_file('progress.hoc')
fih = h.FInitializeHandler(2, "progress(0)")
h.cvode.cache_efficient(1)
pc.barrier() # wait for all hosts to get to this point
h.prun(h.tstop)
pc.barrier() # wait for all hosts to get to this point
h.spike2file('%s/spk.dat' % (workdir_n))
pc.barrier() # wait for all hosts to get to this point
# Save t series values to files.
k = 0
if (utils_obj.description.data['cell_data_tracking']['do_save_t_series'] == 'yes'):
for cell_gid in cells:
if ((cell_gid % utils_obj.description.data['cell_data_tracking']['id_step_save_t_series'] == 0) and (cell_types[type_index(cell_gid)] not in ['LIF_exc', 'LIF_inh'])):
tmp_value_list = []
save_value_out_file_n = '%s/v_out-cell-%d.h5' % (workdir_n, cell_gid)
for i_tmp in xrange(int(h.rec_value_vec_list[save_value_ID_list[k]].size())):
tmp_value_list.append( h.rec_value_vec_list[save_value_ID_list[k]][i_tmp] )
dt = h.rec_t_vec_list[save_value_ID_list[k]][1] - h.rec_t_vec_list[save_value_ID_list[k]][0]
h5 = h5py.File(save_value_out_file_n, 'w', libver='latest')
h5.attrs['dt']=dt
h5.create_dataset('values',(len(tmp_value_list),),maxshape=(None,),chunks=True)
h5['values'][0:len(tmp_value_list)] = tmp_value_list
h5.close()
k += 1
# Save currents from SEClamps.
if (len(h.rec_SEClamp_i_list) > 0):
k = 0
for cell_gid in SEClamp_gids:
if (cell_types[type_index(cell_gid)] in ['LIF_exc', 'LIF_inh']):
continue
tmp_value_list = []
save_value_out_file_n = '%s/i_SEClamp-cell-%d.h5' % (workdir_n, cell_gid)
for i_tmp in xrange(int(h.rec_SEClamp_i_list[k].size())):
tmp_value_list.append( h.rec_SEClamp_i_list[k][i_tmp] )
dt = h.rec_SEClamp_t_list[k][1] - h.rec_SEClamp_t_list[k][0]
h5 = h5py.File(save_value_out_file_n, 'w', libver='latest')
h5.attrs['dt']=dt
h5.create_dataset('values',(len(tmp_value_list),),maxshape=(None,),chunks=True)
h5['values'][0:len(tmp_value_list)] = tmp_value_list
h5.close()
k += 1
pc.barrier() # wait for all hosts to get to this point
# Postprocessing.
if (int(pc.id()) == 0):
f_rate.tot_f_rate(workdir_n+'/spk.dat', workdir_n+'/tot_f_rate.dat', utils_obj.description.data['postprocessing']['in_t_omit'], (h.tstop - utils_obj.description.data['postprocessing']['post_t_omit']), h.tstop, cell_displ[-1])
h.finish()
def __init__(self, description=None):
description = Config().load('manifest.json')
super(Utils, self).__init__(description)
self.generate_cell()
from allensdk.model.biophys_sim.config import Config
from utils import Utils
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import numpy as np
config = Config().load('config.json')
# configure NEURON
utils = Utils(config)
h = utils.h
# configure model
manifest = config.manifest
utils.generate_cells()
utils.connect_cells()
# configure stimulus
utils.setup_iclamp_step(utils.cells[0], 0.27, 1020.0, 750.0)
h.dt = 0.025
h.tstop = 3000
# configure recording
vec = utils.record_values()
# run the model
h.finitialize()
h.run()
import pylab as plt
import visual as vis
from allensdk.model.biophys_sim.config import Config
from utils import Utils
config = Config().load('config.json') # read configuration for the model
utils = Utils(
config
) # instantiate an object of a class Utils which configures NEURONand provides the interface to the necessary functions to set up the simuation
h = utils.h
db = utils.load_cell_db()
cells = utils.generate_cells(db) # read cell information from csv file
print "load connectivity:"
con = utils.load_connectivity()
print 'connecting cells:'
[netcons, syns] = utils.connect_cell(cells, db, con)
print '# of netcons, syns: ', len(netcons), len(syns)
utils.set_run_params() # set h.dt and h.tsop
print "setting stimulus:"
stims = utils.setIClamps(cells)
print "set recordings"
rec_vecs = utils.record_values(cells)
def load_manifest(self):
self.app_config = Config().load(self.input_json)
self.manifest = self.app_config.manifest
fix_sections = ['passive', 'axon_morph,', 'conditions', 'fitting']
self.app_config.fix_unary_sections(fix_sections)
