Source code for emodelrunner.load

"""Functions mainly for loading params for"""

# Copyright 2020-2022 Blue Brain Project / EPFL

# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at


# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# See the License for the specific language governing permissions and
# limitations under the License.

import collections

import json

from bluepyopt import ephys

from emodelrunner.synapses.mechanism import NrnMODPointProcessMechanismCustom
from emodelrunner.locations import multi_locations
from emodelrunner.configuration import get_validated_config

[docs] def load_config(config_path): """Returns the validated configuration file. Args: config_path (str or Path): path to the configuration file. Returns: configparser.ConfigParser: loaded config object """ return get_validated_config(config_path)
[docs] def load_emodel_params(emodel, params_path): """Get optimized parameters. Args: emodel (str): name of the emodel params_path (str): path to the optimized parameters json file Returns: dict: optimized parameters for the given emodel """ with open(params_path, "r", encoding="utf-8") as params_file: params = json.load(params_file) param_dict = params[emodel]["params"] return param_dict
[docs] def get_syn_setup_params( syn_extra_params_path, cpre_cpost_path, fit_params_path, gid, invivo, ): """Load json files and return syn_setup_params dict. Args: syn_extra_params_path (str): path to the glusynapses related extra parameters file cpre_cpost_path (str): path to the c_pre and c_post related file c_pre (resp. c_post) is the calcium amplitude during isolated presynaptic (resp. postsynaptic) activation fit_params_path (str): path to the file containing the glusynapse fitted parameters The fitted parameters are time constant of calcium integrator, depression rate, potentiation rate, and factors used in plasticity threshold computation. gid (int): ID of the postsynaptic cell invivo (bool): whether to run the simulation in 'in vivo' conditions Returns: dict: glusynapse setup related parameters """ with open(syn_extra_params_path, "r", encoding="utf-8") as f: syn_extra_params = json.load(f) with open(cpre_cpost_path, "r", encoding="utf-8") as f: cpre_cpost = json.load(f) with open(fit_params_path, "r", encoding="utf-8") as f: fit_params = json.load(f) return { "syn_extra_params": syn_extra_params, "c_pre": cpre_cpost["c_pre"], "c_post": cpre_cpost["c_post"], "fit_params": fit_params, "postgid": gid, "invivo": invivo, }
[docs] def get_release_params(config, precell=False): """Return the final parameters. Args: config (configparser.ConfigParser): configuration precell (bool): True to load precell optimized parameters. False to get usual parameters. Returns: dict: optimized parameters """ if precell: emodel = config.get("Cell", "precell_emodel") else: emodel = config.get("Cell", "emodel") params_path = config.get("Paths", "params_path") release_params = load_emodel_params(params_path=params_path, emodel=emodel) return release_params
[docs] def load_mechanisms(mechs_path): """Define mechanisms. Args: mechs_path (str): path to the unoptimized parameters json file Returns: list of ephys.mechanisms.NrnMODMechanism from file """ with open(mechs_path, "r", encoding="utf-8") as mechs_file: mechs = json.load(mechs_file) mech_definitions = mechs["mechanisms"] mechanisms_list = [] for sectionlist, channels in mech_definitions.items(): seclist_locs = multi_locations(sectionlist) for channel in channels["mech"]: mechanisms_list.append( ephys.mechanisms.NrnMODMechanism( name=f"{channel}.{sectionlist}", mod_path=None, suffix=channel, locations=seclist_locs, preloaded=True, ) ) return mechanisms_list
[docs] def load_unoptimized_parameters(params_path, v_init, celsius): """Load unoptimized parameters as BluePyOpt parameters. Args: params_path (str): path to the json file containing the non-optimised parameters v_init (int): initial voltage (mV). Will override v_init value from parameter file celsius (int): cell temperature in celsius. Will override celsius value from parameter file Returns: list of parameters """ # pylint: disable=too-many-locals, too-many-branches, too-many-statements parameters = [] with open(params_path, "r", encoding="utf-8") as params_file: definitions = json.load(params_file) # set distributions distributions = collections.OrderedDict() distributions["uniform"] = ephys.parameterscalers.NrnSegmentLinearScaler() distributions_definitions = definitions["distributions"] for distribution, definition in distributions_definitions.items(): if "parameters" in definition: dist_param_names = definition["parameters"] else: dist_param_names = None distributions[ distribution ] = ephys.parameterscalers.NrnSegmentSomaDistanceScaler( name=distribution, distribution=definition["fun"], dist_param_names=dist_param_names, ) params_definitions = definitions["parameters"] if "__comment" in params_definitions: del params_definitions["__comment"] for sectionlist, params in params_definitions.items(): if sectionlist == "global": seclist_locs = None is_global = True is_dist = False elif "distribution_" in sectionlist: is_dist = True seclist_locs = None is_global = False dist_name = sectionlist.split("distribution_")[1] dist = distributions[dist_name] else: seclist_locs = multi_locations(sectionlist) is_global = False is_dist = False bounds = None value = None for param_config in params: param_name = param_config["name"] if isinstance(param_config["val"], (list, tuple)): is_frozen = False bounds = param_config["val"] value = None else: is_frozen = True value = param_config["val"] bounds = None if is_global: # force v_init to the given value if param_name == "v_init": value = v_init elif param_name == "celsius": value = celsius parameters.append( ephys.parameters.NrnGlobalParameter( name=param_name, param_name=param_name, frozen=is_frozen, bounds=bounds, value=value, ) ) elif is_dist: parameters.append( ephys.parameters.MetaParameter( name=f"{param_name}.{sectionlist}", obj=dist, attr_name=param_name, frozen=is_frozen, bounds=bounds, value=value, ) ) else: if "dist" in param_config: dist = distributions[param_config["dist"]] use_range = True else: dist = distributions["uniform"] use_range = False if use_range: parameters.append( ephys.parameters.NrnRangeParameter( name=f"{param_name}.{sectionlist}", param_name=param_name, value_scaler=dist, value=value, bounds=bounds, frozen=is_frozen, locations=seclist_locs, ) ) else: parameters.append( ephys.parameters.NrnSectionParameter( name=f"{param_name}.{sectionlist}", param_name=param_name, value_scaler=dist, value=value, bounds=bounds, frozen=is_frozen, locations=seclist_locs, ) ) return parameters
[docs] def get_rin_exp_voltage_base(features_path): """Get experimental rin voltage base from feature file when having MainProtocol.""" with open(features_path, "r", encoding="utf-8") as features_file: feature_definitions = json.load(features_file) rin_exp_voltage_base = None for feature in feature_definitions["Rin"]["soma.v"]: if feature["feature"] == "voltage_base": rin_exp_voltage_base = feature["val"][0] if rin_exp_voltage_base is None: raise KeyError(f"No voltage_base feature found for 'Rin' in {features_path}") return rin_exp_voltage_base
[docs] def load_syn_mechs( seed, rng_settings_mode, syn_data_path, syn_conf_path, pre_mtypes=None, stim_params=None, use_glu_synapse=False, syn_setup_params=None, ): """Load synapse mechanisms. Args: seed (int): random number generator seed number rng_settings_mode (str): mode of the random number generator Can be "Random123" or "Compatibility" syn_data_path (str): path to the (tsv) synapses data file syn_conf_path (str): path to the synapse configuration data file pre_mtypes (list of ints): activate only synapses whose pre_mtype is in this list. if None, all synapses are activated stim_params (dict or None): dict with pre_mtype as key, and netstim params list as item. netstim params list is [start, interval, number, noise] use_glu_synapse (bool): if True, instantiate synapses to use GluSynapse syn_setup_params (dict): contains extra parameters to setup synapses when using GluSynapseCustom Returns: NrnMODPointProcessMechanismCustom: the synapses mechanisms """ # load synapse file data synapses_data = load_synapses_tsv_data(syn_data_path) # load synapse configuration synconf_dict = load_synapse_configuration_data(syn_conf_path) return NrnMODPointProcessMechanismCustom( "synapse_mechs", synapses_data, synconf_dict, seed, rng_settings_mode, pre_mtypes, stim_params, use_glu_synapse=use_glu_synapse, syn_setup_params=syn_setup_params, )
[docs] def load_synapses_tsv_data(tsv_path): """Load synapse data from tsv. Args: tsv_path (str): path to the tsv synapses data file Returns: list of dicts containing each data for one synapse """ synapses = [] with open(tsv_path, "r", encoding="utf-8") as f: # first line is dimensions for line in f.readlines()[1:]: syn = {} items = line.strip().split("\t") syn["sid"] = int(items[0]) syn["pre_cell_id"] = int(items[1]) syn["sectionlist_id"] = int(items[2]) syn["sectionlist_index"] = int(items[3]) syn["seg_x"] = float(items[4]) syn["synapse_type"] = int(items[5]) syn["dep"] = float(items[6]) syn["fac"] = float(items[7]) syn["use"] = float(items[8]) syn["tau_d"] = float(items[9]) syn["delay"] = float(items[10]) syn["weight"] = float(items[11]) syn["Nrrp"] = float(items[12]) syn["pre_mtype"] = int(items[13]) synapses.append(syn) return synapses
[docs] def load_synapse_configuration_data(synconf_path): """Load synapse configuration data into dict[command]=list(ids). Args: synconf_path (str): path to the synapse configuration data file Returns: dict: configuration data each key contains a command to execute using hoc, and each value contains a list of synapse id on which to execute the command """ synconf_dict = {} with open(synconf_path, "r", encoding="utf-8") as f: synconfs ="-1000000000000000.0") for synconf in synconfs: tmp = synconf.split("\n") if "" in tmp: tmp.remove("") if len(tmp) == 2: cmd, ids = tmp ids = ids.replace(") ", ");") ids = ids.split(";") if "" in ids: ids.remove("") synconf_dict[cmd] = ids return synconf_dict