OSBModelValidation 0.2.18__py3-none-any.whl

omv/analyzers/spikes.py

@@ -0,0 +1,113 @@
+from omv.analyzers.analyzer import OMVAnalyzer
+from omv.analyzers.utils import timeseries as ts
+from omv.analyzers.utils import filenode as fn
+from omv.common.inout import inform
+from os import getcwd
+
+
+class SpikeAnalyzer(OMVAnalyzer):
+    def before_running(self):
+        if "file" in self.observable:
+            self.f = fn.FileNodeHelper(self.observable["file"], self.omt_root)
+            if self.f.tstamp:
+                inform(
+                    "Attention! Preexistent datafile: ",
+                    self.f.filename,
+                    indent=2,
+                    verbosity=1,
+                )
+        if "spiketimes file" in self.observable:
+            self.f = fn.SpikeFileNodeHelper(
+                self.observable["spiketimes file"], self.omt_root
+            )
+            if self.f.tstamp:
+                inform(
+                    "Attention! Preexistent datafile: ",
+                    self.f.filename,
+                    indent=2,
+                    verbosity=1,
+                )
+
+    def parse_spikes(self, to_parse):
+        spikes = []
+        if isinstance(to_parse, list):
+            spikes = to_parse
+        elif "file" in to_parse or "spiketimes file" in to_parse:
+            if not self.f.exists():
+                inform(
+                    "ERROR! Datafile %s does not exist (relative to %s)!"
+                    % (self.f.filename, getcwd()),
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                spikes = None
+            elif not self.f.has_changed():
+                inform(
+                    "ERROR! Datafile %s has not changed!" % self.f.filename,
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                spikes = None
+            elif self.f.has_changed():
+                if "file" in to_parse:
+                    try:
+                        tv = self.f.get_timeseries()
+                    except Exception as e:
+                        inform(
+                            "ERROR! Could not read spikes from datafile %s (%s)!"
+                            % (self.f.filename, e),
+                            indent=2,
+                            verbosity=0,
+                            underline="-",
+                        )
+                        spikes = []
+                        return spikes
+                    inform("Reading timeseries from: ", self.f, indent=1, verbosity=1)
+                    if "spike detection" in to_parse:
+                        sd = to_parse["spike detection"]
+                        method = sd.get("method", "threshold")
+                        threshold = float(sd.get("threshold", 0))
+                        inform(
+                            "Detecting spikes with method: ",
+                            method,
+                            indent=2,
+                            verbosity=1,
+                        )
+                        spikes = ts.spikes_from_timeseries(
+                            tv, method=method, threshold=threshold
+                        )
+                    else:  # file contains spike times
+                        spikes = tv
+
+                elif "spiketimes file" in to_parse:
+                    inform("Reading spiketimes from: ", self.f, indent=1, verbosity=1)
+                    all_spikes = self.f.get_spike_times()
+                    if len(all_spikes) != 1:
+                        inform(
+                            "ERROR! Spike times file %s should contain only spikes for one cell!"
+                            % (self.f.filename),
+                            indent=2,
+                            verbosity=0,
+                            underline="-",
+                        )
+                        return None
+
+                    spikes = list(all_spikes.values())[0]
+            else:
+                inform(
+                    "ERROR! Preexistent datafile %s has not been updated!"
+                    % self.f.filename,
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                spikes = []
+        return spikes
+
+    def parse_expected(self):
+        return self.parse_spikes(self.expected)
+
+    def parse_observable(self):
+        return self.parse_spikes(self.observable)

omv/analyzers/temperature.py

@@ -0,0 +1,12 @@
+from omv.analyzers.analyzer import OMVAnalyzer
+
+
+class TemperatureAnalyzer(OMVAnalyzer):
+    def before_running(self):
+        self.query = self.engine.query_temperature()
+
+    def parse_expected(self):
+        return float(self.expected)
+
+    def parse_observable(self):
+        return float(self.engine.fetch_query(self.query))

omv/analyzers/timeseries.py

@@ -0,0 +1,57 @@
+from omv.analyzers.analyzer import OMVAnalyzer
+from omv.analyzers.utils import timeseries as ts
+from omv.analyzers.utils import filenode as fn
+from omv.common.inout import inform
+
+
+class TimeSeriesAnalyzer(OMVAnalyzer):
+    def before_running(self):
+        if "file" in self.observable:
+            self.fo = fn.FileNodeHelper(self.observable["file"], self.omt_root)
+            if self.fo.tstamp:
+                inform(
+                    "Attention! Preexistent datafile: ",
+                    self.fo.filename,
+                    indent=2,
+                    verbosity=1,
+                )
+
+    def parse_ts(self, to_parse):
+        return ts
+
+    def parse_expected(self):
+        to_parse = self.expected
+        if isinstance(to_parse, list):
+            ts = to_parse
+        elif "file" in to_parse:
+            f = fn.FileNodeHelper(to_parse["file"], self.mep_root)
+            ts = f.get_timeseries()
+            inform("Reading timeseries from: ", f, indent=1, verbosity=1)
+        return ts
+
+    def parse_observable(self):
+        to_parse = self.observable
+        if isinstance(to_parse, list):
+            ts = to_parse
+        elif "file" in to_parse:
+            if not self.fo.has_changed():
+                inform(
+                    "ERROR! Datafile %s does not exist!" % self.fo.filename,
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                ts = []
+            elif self.fo.has_changed():
+                ts = self.fo.get_timeseries()
+                inform("Reading timeseries from: ", self.fo, indent=1, verbosity=1)
+            else:
+                inform(
+                    "ERROR! Preexistent datafile %s has not been updated!"
+                    % self.fo.filename,
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                ts = []
+        return ts

omv/analyzers/utils/filenode.py

@@ -0,0 +1,73 @@
+from omv.analyzers.utils.timeseries import load_data_file, load_spike_file
+from os.path import join, getmtime
+from os.path import exists as os_exists
+
+
+class FileNode(object):
+    def get_timestamp(self):
+        try:
+            return getmtime(self.filename)
+        except OSError:
+            # No preexisting file
+            return None
+
+    def exists(self):
+        return os_exists(self.filename)
+
+    def has_changed(self):
+        return self.get_timestamp() != self.tstamp
+
+
+class FileNodeHelper(FileNode):
+    def __init__(self, fn, root_dir):
+        self.filename = join(root_dir, fn["path"])
+        self.columns = fn.get("columns", (0, 1))
+        self.header = fn.get("header", 0)
+        self.scaling = fn.get("scaling", [1.0] * len(self.columns))
+        self.tstamp = self.get_timestamp()
+
+    def get_timestamp(self):
+        try:
+            return getmtime(self.filename)
+        except OSError:
+            # No preexisting file
+            return None
+
+    def exists(self):
+        return os_exists(self.filename)
+
+    def has_changed(self):
+        return self.get_timestamp() != self.tstamp
+
+    def __str__(self):
+        return str(
+            {
+                "file name": str(self.filename),
+                "columns(time, voltage)": str(self.columns),
+                "initial rows to disregard": str(self.header),
+            }
+        )
+
+    def get_timeseries(self):
+        return load_data_file(self.filename, self.columns, self.header, self.scaling)
+
+
+class SpikeFileNodeHelper(FileNode):
+    def __init__(self, fn, root_dir):
+        self.filename = join(root_dir, fn["path"])
+        self.tstamp = self.get_timestamp()
+        self.format = fn.get("format", 0)
+        self.ids = fn.get("ids", 0)
+        self.scaling = fn.get("scaling", 1)
+
+    def __str__(self):
+        return str(
+            {
+                "spike file name": str(self.filename),
+                "format": str(self.format),
+                "ids": str(self.ids),
+            }
+        )
+
+    def get_spike_times(self):
+        return load_spike_file(self.filename, self.format, self.ids, self.scaling)

omv/analyzers/utils/timeseries.py

@@ -0,0 +1,293 @@
+from omv.common.inout import inform
+
+
+def detect_spikes(v, method="threshold", threshold=0.0):
+    from numpy import flatnonzero, bitwise_and, roll, diff, array
+
+    extrema = array([])
+    if method == "threshold":
+        extrema = 1 + flatnonzero(
+            bitwise_and((v[:-1] <= threshold), (roll(v, -1)[:-1] > threshold))
+        )
+    elif method == "derivative":
+        # This should only work for noiseless cases!
+        dx = diff(v)
+        extrema = 1 + flatnonzero(bitwise_and((dx[:-1] >= 0), (roll(dx, -1)[:-1] < 0)))
+    else:
+        print("still need to implement fancier spike detectors...")
+        # see for example scipy.signal.find_peaks_cwt
+    return extrema
+
+
+def load_data_file(fname, columns=(0, 1), header_lines=0, scaling=1):
+    from numpy import loadtxt
+
+    ts = loadtxt(fname, usecols=columns, skiprows=header_lines)
+    return ts * scaling
+
+
+def load_spike_file(fname, format="ID_TIME", ids=0, scaling=1.0):
+    from numpy import loadtxt
+
+    ts = loadtxt(fname, skiprows=3) if format == "ID_TIME_NEST_DAT" else loadtxt(fname)
+    spike_map = {}
+    for l in ts:
+        # print('Interpreting: %s'%l)
+        if format == "ID_TIME" or format == "ID_TIME_NEST_DAT":
+            t = l[1] * scaling
+            id = l[0]
+        elif format == "TIME_ID":
+            t = l[0] * scaling
+            id = l[1]
+        if ids == id or ids == "*":
+            if not id in spike_map:
+                spike_map[id] = []
+            spike_map[id].append(t)
+    return spike_map
+
+
+def compare_arrays(arrays, tolerance):
+    from numpy import allclose, array, max, abs, atleast_1d
+
+    # if array conversion fails, also fail test
+    try:
+        a1, a2 = array(arrays)
+    except ValueError as e:
+        print(e)
+        return (False, 0)
+
+    if (hasattr(a1, "__len__") or hasattr(a2, "__len__")) and len(a1) != len(
+        a2
+    ):  # Different lengths!!
+        return (False, 0)
+
+    best_tol = None
+    try:
+        comp = allclose(a1, a2, tolerance)
+        if len(atleast_1d(a1)) > 0:
+            best_tol = max(abs((a1 - a2) / a2))
+    except ValueError:
+        comp = False
+    return (comp, best_tol)
+
+
+def compare_dictionaries(d1, d2, tolerance=0.1):
+    from numpy import allclose, array
+
+    ks = d1.keys() if len(d1) < len(d2) else d2.keys()
+    a1 = array([d1[k] for k in ks if k in d1])
+    a2 = array([d2[k] for k in ks if k in d2])
+    return allclose(a1, a2, tolerance)
+
+
+def load_spike_times(spiketime):
+    if isinstance(spiketime, list):
+        return spiketime
+    else:
+        return load_data_file(spiketime, [0])
+
+
+def spikes_from_timeseries(ts, **kwargs):
+    method = kwargs.get("method", "threshold")
+    threshold = kwargs.get("threshold", 0)
+    t, v = ts.T
+    spk_idx = detect_spikes(v, method, threshold)
+    return t[spk_idx]
+
+
+def spikes_from_datafile(
+    path, columns=(0, 1), header=0, method="threshold", threshold=0
+):
+    t, v = load_data_file(path, columns, header)
+    spk_idx = detect_spikes(v, method, threshold)
+    return t[spk_idx]
+
+
+def average_resting(tv, window, col=1):
+    from numpy import mean
+
+    return mean(tv[-window:, col])
+
+
+def input_resistance(tv, ti, h_window, cmd_window, voltages, col=1):
+    from numpy import mean, where
+
+    t = ti[:, 0]
+    # print(cmd_window
+    t_holding = where((t >= h_window[0]) & (t <= h_window[1]))
+    t_cmd = where((t >= cmd_window[0]) & (t <= cmd_window[1]))
+    holding_i = mean(ti[t_holding, col])
+    command_i = mean(ti[t_cmd, col])
+    holding_v = mean(tv[t_holding, col])
+    command_v = mean(tv[t_cmd, col])
+    i_step = command_i - holding_i
+    v_step = command_v - holding_v  # voltages[0]-voltages[1]
+    # print(v_step, i_step, holding_i, command_i
+    input_resistance = v_step / i_step
+    return input_resistance
+
+
+def all_within_bounds(ts, bounds=(0, 1)):
+    from numpy import all
+
+    # print(type(bounds[0]),bounds[0],bounds[1], ts.size
+    return all((ts[:, 1:] >= bounds[0]) & (ts[:, 1:] <= bounds[1]))
+
+
+def all_nonzero(ts):
+    from numpy import all
+
+    return all(ts[:, 1:])
+
+
+def pretty_print_copypaste(obs, exp):
+    from numpy import atleast_1d
+
+    ob = atleast_1d(obs)
+    ex = atleast_1d(exp)
+    suggest_tol = False
+    try:  # making it easier to copy/paste lists
+        pretty_obs = [float(el) for el in ob]
+        pretty_exp = [float(el) for el in ex]
+        suggest_tol = len(ob) == len(ex)
+
+    except (
+        Exception
+    ) as e:  # obs, exp can be rank > 1. Not sure if we would ever c&p those
+        pretty_obs, pretty_exp = (str(ob), str(ex))
+
+    return pretty_obs, pretty_exp
+
+
+def test_detect_spikes():
+    from numpy import array, all, arange
+
+    x = array([-1, 0, 1, 0] * 10)
+
+    spk_idx = detect_spikes(x, method="derivative")
+    assert all(spk_idx == arange(2, len(x), 4))
+
+    spk_idx = detect_spikes(x, method="threshold", threshold=0.1)
+    assert all(spk_idx == arange(2, len(x), 4))
+
+    xx = -x  # edge case: first point > threshold
+    spk_idx = detect_spikes(xx, method="derivative")
+    assert all(spk_idx == arange(4, len(xx), 4))
+
+    spk_idx = detect_spikes(xx, method="threshold", threshold=0.1)
+    assert all(spk_idx == arange(4, len(xx), 4))
+
+
+def _get_single_spike_rate(spiketimes, method, start_time, end_time):
+    if method == ISI_BASED_SPIKERATE_CALC:
+        isis = []
+        tot_isi = 0
+        for si in range(len(spiketimes) - 1):
+            if (
+                spiketimes[si + 1] >= start_time
+                and spiketimes[si + 1] <= end_time
+                and spiketimes[si] >= start_time
+                and spiketimes[si] <= end_time
+            ):
+                isi = spiketimes[si + 1] - spiketimes[si]
+                isis.append(isi)
+                tot_isi += isi
+        if len(isis) > 0:
+            rate = len(isis) / float(tot_isi)
+        else:
+            rate = 0
+        inform(
+            "Spikes (%i): %s, qualifying ISIs: %s, rate: %s"
+            % (len(spiketimes), spiketimes, isis, rate),
+            verbosity=2,
+            indent=2,
+        )
+
+    elif method == DURATION_BASED_SPIKERATE_CALC:
+        dur = float(end_time - start_time)
+        spikes_in = 0
+        for s in spiketimes:
+            if s >= start_time and s <= end_time:
+                spikes_in += 1
+        rate = spikes_in / dur
+        inform(
+            "Spikes %i of %i inside range %s->%s, so rate %s"
+            % (spikes_in, len(spiketimes), start_time, end_time, rate),
+            verbosity=2,
+            indent=2,
+        )
+        return rate
+
+    else:
+        raise Exception("Unknown method for calculating rates: %s" % method)
+
+    return rate
+
+
+ISI_BASED_SPIKERATE_CALC = "isi based"
+DURATION_BASED_SPIKERATE_CALC = "duration based"
+
+
+def get_spike_rate(
+    spikes, method=ISI_BASED_SPIKERATE_CALC, start_time=0, end_time=float("inf")
+):
+    inform(
+        'Calculating average of %i spike rate(s) with method "%s" from %s->%s'
+        % (len(spikes), method, start_time, end_time),
+        verbosity=1,
+        indent=2,
+    )
+
+    if isinstance(spikes, list):
+        return _get_single_spike_rate(spikes, method, start_time, end_time)
+
+    if isinstance(spikes, dict):
+        tot_rates = 0
+        all_rates = []
+        if len(spikes) == 0:
+            avg_rate = 0
+        else:
+            for s in spikes.values():
+                r = _get_single_spike_rate(s, method, start_time, end_time)
+                all_rates.append(r)
+                tot_rates += r
+            avg_rate = float(tot_rates) / len(spikes)
+        inform(
+            'Calculated average of %i spike rate(s) with method "%s": %s %s'
+            % (len(spikes), method, avg_rate, all_rates),
+            verbosity=1,
+            indent=2,
+        )
+        return avg_rate
+
+
+if __name__ == "__main__":
+    from omv.common.inout import set_verbosity
+
+    set_verbosity(2)
+
+    tsNone = []
+    tsA = [0.1]
+    tsB = [0.1, 0.2]
+
+    ts1 = [0.1, 0.2, 0.3, 0.40]
+    ts2 = [0.1, 0.3, 0.50]
+
+    methods = [ISI_BASED_SPIKERATE_CALC, DURATION_BASED_SPIKERATE_CALC]
+
+    for method in methods:
+        opts = [tsNone, tsA, tsB, ts1, ts2, {"0": ts1}, {"0": ts1, "1": ts2}]
+        for opt in opts:
+            start_time = 0
+            end_time = 0.25
+            inform(
+                " > Rate in %s->%s (%s) for %s: %s\n"
+                % (
+                    start_time,
+                    end_time,
+                    method,
+                    opt,
+                    get_spike_rate(opt, method, start_time, end_time),
+                ),
+                indent=2,
+            )

omv/autogen.py

@@ -0,0 +1,106 @@
+from os.path import isdir, join, split
+from glob import glob
+import yaml
+
+# ugly hack to get .travis.yaml closer to manual version
+from collections import OrderedDict
+
+
+class UnsortableList(list):
+    def sort(self, *args, **kwargs):
+        pass
+
+
+class UnsortableOrderedDict(OrderedDict):
+    def items(self, *args, **kwargs):
+        return UnsortableList(OrderedDict.items(self, *args, **kwargs))
+
+
+yaml.add_representer(
+    UnsortableOrderedDict, yaml.representer.SafeRepresenter.represent_dict
+)
+
+
+def read_option(options, default=0):
+    for i, opt in enumerate(options):
+        print("\t\t", i, opt)
+    opt = None
+    while opt is None:
+        try:
+            sel = int(raw_input("Select option number [default: %s]: " % default))
+            opt = options[sel]
+        except IndexError:
+            print("invalid index!")
+        except ValueError:
+            print("selecting default: " + default)
+            opt = options[default]
+    return opt
+
+
+def find_targets(auto=False):
+    # TODO: should belong to engine
+    dirs_to_engines_exts = {
+        "NEURON": {"engine": "NEURON", "extension": ".hoc"},
+        "NeuroML2": {"engine": "jNeuroML", "extension": ".nml"},
+    }
+    targets = []
+    for d, eng_ext in dirs_to_engines_exts.items():
+        if isdir(d):
+            engine = dirs_to_engines_exts[d]["engine"]
+            ext = dirs_to_engines_exts[d]["extension"]
+            print("Default directory for {0} engine found.".format(engine))
+            print("  Will look for scripts with {0} extension".format(ext))
+            scripts = glob(join(d, "*" + ext))
+            if scripts:
+                if auto:
+                    print("selecting default: ", scripts[0])
+                    script = scripts[0]
+                else:
+                    script = read_option(scripts)
+                targets.append((engine, script))
+    return targets
+
+
+def create_dryrun(engine, target):
+    print(
+        " ".join(("Generating dry run test for file", target, ", using engine", engine))
+    )
+    dirname, fname = split(target)
+    omt = {"target": fname, "engine": engine}
+    with open(target + ".dry.omt", "w") as fh:
+        yaml.dump(omt, fh, default_flow_style=False)
+
+
+def generate_dottravis(targets):
+    engines = [t[0] for t in targets]
+    engines = ["OMV_ENGINE=" + be for be in engines]
+    # TODO: softcode
+    repo = "git+https://github.com/borismarin/osb-model-validation.git"
+
+    travis = UnsortableOrderedDict(
+        [
+            ("language", "python"),
+            ("python", 2.7),
+            ("env", engines),
+            ("install", ["pip install " + repo]),
+            ("script", ["omv all"]),
+        ]
+    )
+
+    with open(".travis.yml", "w") as fh:
+        fh.write(yaml.dump(travis, default_flow_style=False))
+
+
+def autogen(auto=False, dry=True):
+    targets = find_targets(auto)
+    if targets:
+        for engine, target in targets:
+            if dry:
+                create_dryrun(engine, target)
+        generate_dottravis(targets)
+    else:
+        print("No target scripts found!")
+
+
+if __name__ == "__main__":
+    autogen()