def test_load_module():
"""bluepymm.tools: test load_module"""
# load module
module_dir = os.path.join(EXAMPLES, 'simple1/data/emodels_dir/subdir/')
setup = tools.load_module('setup', module_dir)
# try and execute something from loaded module
setup.evaluator.create('emodel1')
# load as file
setup_dir = os.path.join(module_dir, 'setup')
evaluator = tools.load_module('evaluator', setup_dir)
evaluator.create('emodel1')
def create_and_write_hoc_file(emodel, emodel_dir, hoc_dir, emodel_params,
template, template_dir=None, morph_path=None,
model_name=None):
"""Create .hoc code for a given e-model based on code from
'<emodel_dir>/setup', e-model parameters and a given template, and write
out the result to a file named <hoc_dir>/<model_name or emodel>.hoc.
Args:
emodel: e-model name
emodel_dir: the directory containing a module 'setup', which describes
the e-model
hoc_dir: the directory to which the resulting .hoc file will be written
out.
emodel_params: a dict with e-model parameters
template: template file used for the creation of the .hoc file
template_dir: directory that contains the template. If None, a template
provided by BluePyMM is used. Default is None.
morph_path: path to morphology file, used to overwrite the original
morphology of an e-model. Default is None.
model_name: used to name the .hoc file. If None, the e-model name is
used. Default is None.
"""
setup = tools.load_module('setup', emodel_dir)
with open(os.devnull, 'w') as devnull:
old_stdout = sys.stdout
try:
sys.stdout = devnull
if hasattr(setup, 'multieval'):
evaluator = setup.evaluator.create(emodel).evaluators[0]
else:
evaluator = setup.evaluator.create(emodel)
# set path to morphology
if morph_path is not None:
evaluator.cell_model.morphology.morphology_path = morph_path
# set template name
template_name = model_name or emodel
evaluator.cell_model.name = template_name
evaluator.cell_model.check_name()
finally:
sys.stdout = old_stdout
# create hoc code
if template_dir is None:
template_dir = TEMPLATE_DIR
for mechanism in evaluator.cell_model.mechanisms:
if 'Stoch' in mechanism.prefix:
mechanism.deterministic = False
hoc = evaluator.cell_model.create_hoc(emodel_params, template=template,
template_dir=template_dir)
# write out result
hoc_file_name = '{}.hoc'.format(template_name)
emodel_hoc_path = os.path.join(hoc_dir, hoc_file_name)
with open(emodel_hoc_path, 'w') as emodel_hoc_file:
emodel_hoc_file.write(hoc)
def create_arg_list(scores_db_filename, emodel_dirs, final_dict,
extra_values_error=False, use_apical_points=True):
"""Create list of argument tuples to be used as an input for
run_emodel_morph.
Args:
scores_db_filename: path to .sqlite database
emodel_dirs: a dict mapping e-models to the directories with e-model
input files
final_dict: a dict mapping e-models to dicts with e-model parameters
extra_values_error: boolean to raise an exception upon a missing key
use_apical_points: boolean to use apical points or not
Raises:
ValueError, if one of the database entries contains has value None for
the key 'emodel'.
"""
arg_list = []
with sqlite3.connect(scores_db_filename) as scores_db:
scores_db.row_factory = sqlite3.Row
one_row = scores_db.execute('SELECT * FROM scores LIMIT 1').fetchone()
apical_points_isec = {}
setup = tools.load_module('setup', emodel_dirs[one_row['emodel']])
if hasattr(setup, 'multieval') and use_apical_points:
apical_points_isec = tools.load_json(
os.path.join(one_row['morph_dir'], "apical_points_isec.json")
)
scores_cursor = scores_db.execute('SELECT * FROM scores')
for row in scores_cursor.fetchall():
index = row['index']
morph_name = row['morph_name']
morph_ext = row['morph_ext']
if morph_ext is None:
morph_ext = '.asc'
apical_point_isec = None
if morph_name in apical_points_isec:
apical_point_isec = int(apical_points_isec[morph_name])
morph_filename = morph_name + morph_ext
morph_path = os.path.abspath(os.path.join(row['morph_dir'],
morph_filename))
if row['to_run'] == 1:
emodel = row['emodel']
original_emodel = row['original_emodel']
if emodel is None:
raise ValueError(
"scores db row %s for morph %s, etype %s, mtype %s, "
"layer %s doesn't have an e-model assigned to it" %
(index, morph_name, row['etype'], row['mtype'],
row['layer']))
args = (index, emodel,
os.path.abspath(emodel_dirs[emodel]),
final_dict[original_emodel]['params'],
morph_path, apical_point_isec, extra_values_error)
arg_list.append(args)
print('Found %d rows in score database to run' % len(arg_list))
return arg_list
def run_emodel_morph(
emodel,
emodel_dir,
emodel_params,
morph_path,
apical_point_isec,
extra_values_error=True):
"""Run e-model morphology combination.
Args:
emodel: e-model name
emodel_dir: directory containing e-model files
emodel_params: dict that maps e-model parameters to their values
morph_path: path to morphology
apical_point_isec: integer value of the apical point isection
extra_values_error: boolean to raise an exception upon a missing key
Returns:
tuple:
- dict that maps features to scores
- dict with extra values: 'holding_current' and 'threshold_current'
"""
try:
sys.stdout = open('/dev/null', 'w')
print('Running e-model %s on morphology %s in %s' %
(emodel, morph_path, emodel_dir))
setup = tools.load_module('setup', emodel_dir)
print("Changing path to %s" % emodel_dir)
with tools.cd(emodel_dir):
if hasattr(setup, 'multieval'):
prefix = 'mm'
altmorph = [[prefix, morph_path, apical_point_isec]]
evaluator = setup.evaluator.create(etype='%s' % emodel,
altmorph=altmorph)
evaluator = evaluator.evaluators[0] # only one evaluator
responses = evaluator.run_protocols(
evaluator.fitness_protocols.values(),
emodel_params)
scores = evaluator.fitness_calculator.calculate_scores(
responses)
extra_values = {}
for response_key, extra_values_key in [
('%s.bpo_holding_current' % prefix,
'holding_current'),
('%s.bpo_threshold_current' % prefix,
'threshold_current')]:
if response_key in responses:
extra_values[extra_values_key] = responses[
response_key]
else:
if extra_values_error:
raise ValueError(
"Key %s not found in responses: %s" %
(response_key, str(responses)))
else:
extra_values[extra_values_key] = None
else:
evaluator = setup.evaluator.create(etype='%s' % emodel)
evaluator.cell_model.morphology.morphology_path = morph_path
responses = evaluator.run_protocols(
evaluator.fitness_protocols.values(),
emodel_params)
scores = evaluator.fitness_calculator.calculate_scores(
responses)
extra_values = {}
extra_values['holding_current'] = \
responses.get('bpo_holding_current', None)
extra_values['threshold_current'] = \
responses.get('bpo_threshold_current', None)
return scores, extra_values
except Exception:
# Make sure exception and backtrace are thrown back to parent process
raise Exception(
"".join(traceback.format_exception(*sys.exc_info())))
