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())))