OSBModelValidation 0.2.18__py3-none-any.whl

OSBModelValidation-0.2.18.dist-info/METADATA

@@ -0,0 +1,184 @@
+Metadata-Version: 2.1
+Name: OSBModelValidation
+Version: 0.2.18
+Summary: Open Source Brain Model validation
+Home-page: https://github.com/OpenSourceBrain/osb-model-validation
+Author: Boris Marin, Padraig Gleeson
+Author-email: borismarin@gmail.com
+License: LGPL-3.0-only
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 (LGPLv3)
+Classifier: Natural Language :: English
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Scientific/Engineering
+Description-Content-Type: text/markdown
+Requires-Dist: PyYAML
+Requires-Dist: numpy
+Requires-Dist: pyrx
+Requires-Dist: docopt
+Requires-Dist: pathlib ; python_version < "3.4"
+Requires-Dist: importlib-metadata ; python_version < "3.8"
+
+[![Continuous builds](https://github.com/OpenSourceBrain/osb-model-validation/actions/workflows/ci.yml/badge.svg)](https://github.com/OpenSourceBrain/osb-model-validation/actions/workflows/ci.yml)
+[![PyPI](https://img.shields.io/pypi/v/osb-model-validation)](https://pypi.org/project/osb-model-validation/)
+[![PyPI - Python Version](https://img.shields.io/pypi/pyversions/osb-model-validation)](https://pypi.org/project/osb-model-validation/)
+[![GitHub](https://img.shields.io/github/license/OpenSourceBrain/osb-model-validation)](https://github.com/OpenSourceBrain/osb-model-validation/blob/master/LICENSE.lesser)
+[![GitHub pull requests](https://img.shields.io/github/issues-pr/OpenSourceBrain/osb-model-validation)](https://github.com/OpenSourceBrain/osb-model-validation/pulls)
+[![GitHub issues](https://img.shields.io/github/issues/OpenSourceBrain/osb-model-validation)](https://github.com/OpenSourceBrain/osb-model-validation/issues)
+[![Gitter](https://badges.gitter.im/NeuroML/community.svg)](https://gitter.im/NeuroML/community?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge)
+------------------------------------------
+
+# OSB Model Validation
+
+Tools for automated model validation in [Open Source Brain](http://www.opensourcebrain.org) projects, which can also be used for testing model behaviour on many [simulation engines](https://github.com/OpenSourceBrain/osb-model-validation/tree/master/omv/engines) both:
+
+- on your local machine when developing models
+- on [GitHub Actions](https://github.com/features/actions), to ensure tests pass on every commit.
+
+To see this framework in action, click on some of the green buttons below:
+
+|  OSB project   |   Tests on GitHub Actions    |  Test workflow script |
+|----------|:-------------:|:------:|
+|[FitzHugh Nagumo](http://www.opensourcebrain.org/projects/fitzhugh-nagumo-fitzhugh-1969) | [![Continuous build using OMV](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/actions/workflows/omv-ci.yml/badge.svg)](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/actions/workflows/omv-ci.yml) | [omv-ci.yml](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/blob/master/.github/workflows/omv-ci.yml) |
+|[Auditory cortex network](http://www.opensourcebrain.org/projects/acnet2)| [![Continuous build using OMV](https://github.com/OpenSourceBrain/ACnet2/actions/workflows/omv-ci.yml/badge.svg)](https://github.com/OpenSourceBrain/ACnet2/actions/workflows/omv-ci.yml) | [omv-ci.yml](https://github.com/OpenSourceBrain/ACnet2/blob/master/.github/workflows/omv-ci.yml) |
+| [SBML Showcase](http://www.opensourcebrain.org/projects/sbmlshowcase)| [![Continuous build using OMV](https://github.com/OpenSourceBrain/sbmlshowcase/actions/workflows/omv-ci.yml/badge.svg)](https://github.com/OpenSourceBrain/sbmlshowcase/actions/workflows/omv-ci.yml) | [omv-ci.yml](https://github.com/OpenSourceBrain/sbmlshowcase/blob/master/.github/workflows/omv-ci.yml) |
+
+This framework has been used to test the 30+ NeuroML and PyNN models described in the [Open Source Brain paper (Gleeson et al. 2019)](https://www.cell.com/neuron/fulltext/S0896-6273(19)30444-1), and [many more](https://github.com/OpenSourceBrain/.github/blob/main/testsheet/README.md).
+
+## Installation
+
+Quick system-wide install:
+
+``` bash
+pip install osb-model-validation
+```
+
+Or you can install from cloned repository (preferably in a virtual environment):
+
+``` bash
+git clone https://github.com/OpenSourceBrain/osb-model-validation.git
+cd osb-model-validation
+pip install .
+```
+
+## Instructions
+
+Any _Open Source Brain_ project can have automated testing incorporated.
+For an overview of the various Open Source Brain projects with OMV tests, see https://github.com/OpenSourceBrain/.github/blob/main/testsheet/README.md (note not all of these use OMV yet).
+
+Setting up validation for a model and simulation written in NeuroML2/LEMS requires two additional steps:
+
+- write a <b>M</b>odel <b>E</b>mergent <b>P</b>roperties (_mep_) file.
+- write the corresponding <b>O</b>SB <b>M</b>odel <b>T</b>est (_omt_) file.
+
+
+### Write MEP files
+
+Depending on the size of your model, you can run validation on the full fledged model, or you can create smaller stripped down versions that test particular aspects of the model.
+Here is an example LEMS file for the FitzHugh-Nagumo model on Open Source Brain: [LEMS_FitzHugNagamo.xml](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/blob/master/NeuroML2/LEMS_FitzHughNagumo.xml).
+
+``` yaml
+# Script for running automated tests on OSBrain, see https://github.com/OpenSourceBrain/osb-model-validation
+
+system: The Fitzhugh-Nagumo model, classical parameters
+
+experiments:
+  experiment 1, free run:
+    expected:
+      spike times: [2.24, 39.82, 76.53, 113.24, 149.94, 186.65, 223.36, 260.07, 296.78, 333.49, 370.2]
+```
+
+MEP files include information on what is expected from the simulation run.
+OMV will run the simulation based on the OMT files (which we'll see below), and compare the output to the information provided in MEP files.
+Multiple _experiments_ can be mentioned in the MEP file, and each project can have multiple MEP files.
+
+The MEP file for the FitzHugh-Nagumo model is [here](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/blob/master/fhn.mep).
+It includes a single experiment, with the expected spike times that the simulation run should generate.
+
+### Writing OMT files
+
+OMT files include information on simulating the model for validation.
+The FitzHugh-Nagumo model on Open Source Brain includes multiple OMT files that can be seen [here](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/tree/master/NeuroML2).
+
+- Each OMT file specifies a _target_ file, which is the LEMS simulation file to be run.
+
+- Each OMT file specifies an _engine_ that OMV supports.
+    Engines are simulators that OMV should use to run the model. See [here](https://github.com/OpenSourceBrain/osb-model-validation/tree/master/omv/engines) for the current list.
+    For example, the [.test.fhn.jnml.omt](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/blob/master/NeuroML2/.test.fhn.jnml.omt) file uses the `jNeuroML` engine, which implies that the model should be run using plain jNeuroML (and not any of the simulators that jNeuroML supports, like NEURON).
+
+``` yaml
+# Script for running automated tests on OSB, see https://github.com/OpenSourceBrain/osb-model-validation
+
+target: LEMS_FitzHughNagumo.xml
+engine: jNeuroML
+mep: ../fhn.mep
+experiments:
+  experiment 1, free run:
+    observables:
+      spike times:
+        file:
+          path: ./fhn.dat
+          columns: [0,1]
+          scaling: [1000, 1]
+        spike detection:
+          method: derivative
+        tolerance: 2.185696883946938e-16
+```
+
+- Each OMT file specifies the MEP file that the output of its simulation run should be compared to.
+    In this case, we use the same MEP file for all OMT files.
+
+- Finally, like MEP files, OMT files also include _experiments_.
+    The names of the experiments in the OMT files must correspond to those used in the MEP files, so that OMV knows what section of the OMT and MEP files are related to each other.
+    In each experiment, we specify our _observables_, which are to be compared to the information provided in the MEP file.
+    Here, we inform OMV that we are observing _spike times_, which will be recorded by the simulation run in `fhn.dat`.
+    We also inform OMV what columns of this file the information is to be extracted from, and if these columns need to be scaled before they are compared to the data provided in the MEP file.
+    Finally, while simulations can save spike times directly and OMV will compare these to the MEP file, if the simulation is recording membrane potentials, OMV can also be asked to detect spikes from this data using the _spike detection_ section.
+    The _tolerance_ key tells OMV what the acceptable difference between the expected and observed data values is.
+
+This is the OMT file to validate the same model using the `jNeuroML_NEURON` engine: [.test.fhn.jnmlnrn.omt](https://github.com/OpenSourceBrain/FitzHugh-Nagumo/blob/master/NeuroML2/.test.fhn.jnmlnrn.omt).
+It uses the same MEP file, and observes the same recorded information.
+It only tells OMV to use a different simulation engine:
+
+``` yaml
+# Script for running automated tests on OSB, see https://github.com/OpenSourceBrain/osb-model-validation
+
+target: LEMS_FitzHughNagumo.xml
+engine: jNeuroML_NEURON
+mep: ../fhn.mep
+experiments:
+  experiment 1, free run:
+    observables:
+      spike times:
+        file:
+          path: ./fhn.dat
+          columns: [0,1]
+          scaling: [1000, 1]
+        spike detection:
+          method: derivative
+        tolerance: 0
+```
+### Running validation tests locally
+
+If you have installed OMV successfully, you can now run all the OMV tests locally, by running this command:
+
+    omv all
+
+Adding the `-V` flag prints more details on successful/failed runs. Learn more about the options that `omv` can take by running `omv --help`.
+
+To see what [engines](https://github.com/OpenSourceBrain/osb-model-validation/tree/master/omv/engines) are currently installed (and what their versions are) type:
+
+    omv list -V  
+
+Running validation tests locally ensures that you can quickly check if any changes you have made to the model cause changes to its specific outcomes.
+Since you can run the validation with different [engines](https://github.com/OpenSourceBrain/osb-model-validation/tree/master/omv/engines) to use different simulators, this also allows you to quickly verify that your model gives similar results using these different tools.
+
+
+### Running tests automatically on GitHub Actions
+
+To use OMV with GHA, copy an existing configuration file, e.g. https://github.com/OpenSourceBrain/ACnet2/blob/master/.github/workflows/omv-ci.yml and place it in the required repository.

OSBModelValidation-0.2.18.dist-info/RECORD

@@ -0,0 +1,98 @@
+omv/__init__.py,sha256=49azS5RmLVlyUgahfuNDLANpz_xQ0lfw1LQ_vhLPVik,221
+omv/autogen.py,sha256=k866pebE7LMrsdknVEP7FT-f7ZmwMIL5jX36EzechlU,3097
+omv/experiment.py,sha256=FL76vNGdLLoblGnouRJrNjDFj2ci7WZ0yLSpPEtFXaA,624
+omv/find_tests.py,sha256=U4H4PJswWf24YGIhzVCUr6RaRiM-5dAEpNgQVuvJY30,3873
+omv/omt_mep_parser.py,sha256=of9FY4my7VA8QSKFQTiGoB_aUNV-DKs_GPw8qZGmjXg,1844
+omv/omv_util.py,sha256=cFqU6zSlKYZC_j0re-lyqef8MTINdt2nzhM8QmLChmc,14466
+omv/parse_omt.py,sha256=lZeHkUkgqEOk0adsmx8yQvHjdOq9YPG4mMPcrlFbTXM,4260
+omv/tally.py,sha256=mMr-b-24nGNSIvmUSQdeXIP8W8JvtcJd_Dk5kSSi1go,3536
+omv/analyzers/__init__.py,sha256=5QS2b80PQTa_keGnYlW3z_C7JxZDt6qd5zEEDSG03SA,843
+omv/analyzers/activation.py,sha256=ZZncQ17Uvqgm4mzBZ3Js9uF0ZHyhP9N4ZiWMAZCps8o,830
+omv/analyzers/analyzer.py,sha256=WdG5FPHOSW3kpjHcQLeo4j_G0qJdAyYWwVPvBOj0TqY,2583
+omv/analyzers/dryrun.py,sha256=tSXGhunJX7giFa9Atiagbki2-qS_Fxvo_NayJHUBuOA,397
+omv/analyzers/input_resistance.py,sha256=VbYryoRob-1FrvBgjzeG2VuLF-zXHDw7o5xZwbFiSSM,1587
+omv/analyzers/morphology.py,sha256=gceVlkaD7czG8RyQuFUNzRECKUkx8tAYzSvV5O9RkvY,530
+omv/analyzers/rates.py,sha256=ya3ARBc5dvEjmQzWqR-CpYJJopa4J5jMSsfxFg-4qdQ,3722
+omv/analyzers/resting.py,sha256=7C0d5hsVmJd08wSUsICFI76nvngER7H62n9-QOLMNyY,1270
+omv/analyzers/spikes.py,sha256=-C00aax6cSSVDfjw0yImmQRkXGA9REyxRUhdfH1xIqs,4373
+omv/analyzers/temperature.py,sha256=PYI6KYTk-LRKl8LDskwdL9uykdExA7Kc2iVd4FzwC6A,330
+omv/analyzers/timeseries.py,sha256=Y5nvJ-wyD-fFwK7L-gPyRFIaL0MITT_PIauJcd9vh7Y,1943
+omv/analyzers/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omv/analyzers/utils/filenode.py,sha256=qJfxzEuOPPEvWmkuZMsk-Lx_XyRoB_eYdLAbZZj0m30,2119
+omv/analyzers/utils/timeseries.py,sha256=q9vupQWfCK--p3ZxiHcG-tX8PqzXBKFH-1u6hKdoB3c,8505
+omv/common/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omv/common/inout.py,sha256=UKMtWI_8GS5F360Ucam3EqHI8bF95pHH7qwkspQ86RA,3877
+omv/engines/__init__.py,sha256=MkDTljoYQ-uut_WCLbvhedCI02jLif77kVmOEByQ3-s,2229
+omv/engines/arbor_.py,sha256=OzeZUFUzXMbfmmSmlr3mwYdYFo-DGnt6a3v7R0ixlTU,1675
+omv/engines/brian1.py,sha256=GAzZ7KCzeI25SVx6n8oytQOHGW5bdvM2ZSNjhLngJso,1732
+omv/engines/brian2_.py,sha256=ehDduB9eH_da-l6ilkv1ixgbvyMqd4h2lbyCvdA2kRU,1699
+omv/engines/eden_.py,sha256=k_tw6AE--1_Maa8CT1UZoWAaI2iN25U5FAVj8yS8sBk,1832
+omv/engines/engine.py,sha256=QGCjiAv6XZ1fVaVOfEh85VfaAONysywI_KlS158VSDs,3460
+omv/engines/genesis.py,sha256=EO12AvkBCLVxtdpKsFrcH1A6gYjG5GilTvbHOyn9HbI,2868
+omv/engines/getarbor.py,sha256=q9Vp8du64fqTgqJvBqIkdeh4QdAh5v57VB4Oy-bMuJg,347
+omv/engines/getbrian1.py,sha256=RkFzxSVw8l0y4nz_Jlibvdh6sPXG5zBZL5EJJNtc6J8,1492
+omv/engines/getbrian2.py,sha256=VPh1ZwUpH3OPGj-P0a_DnWuwI_rpAa63WBZowFkgrXY,393
+omv/engines/geteden.py,sha256=hMdmMgwvCM_8NUeSswz_pwvQxVuqth_XVv0DYyhSPEE,392
+omv/engines/getgenesis.py,sha256=Q0TG0dy2U-rTYCeqPsP8ZqqK9YglHIoXMN_gN2-lEAo,2342
+omv/engines/getjlems.py,sha256=9z3BSN6DBVrNiHotMN51N5ayW0qn8azUAVl7Kd20Jpo,613
+omv/engines/getjnml.py,sha256=clKR4Sq9i_HQ7yqkp4Wrpcgc1ZkHeLTd2Idc8eGLKmI,1464
+omv/engines/getlibsbml.py,sha256=Wr9lgf2WXaw8NXICY5CI-ry_p0bQEX8aB91JTWzihGU,358
+omv/engines/getmoose.py,sha256=33eObTqFLB62w0Zz7O_WdL4K89j9BOp9qYx5BL8S_Sg,339
+omv/engines/getnest.py,sha256=YH1UtPsy7LSJhVcqSDN_lqcWHfnDpkrutjAaSOjBiak,1967
+omv/engines/getnetpyne.py,sha256=zYb9V-0MMw9iN9jbMEWDS5Aoheev3wUnm7v7m5SNtGA,1647
+omv/engines/getneuroconstruct.py,sha256=797-0SmRw4NixmGz7Z7em_6lvrK4KRSlKyBiK8M1-HA,850
+omv/engines/getnml2.py,sha256=UtpvetXojFuv_GbNNwZCsORnwdfnr9L3ZeELykZ11gU,744
+omv/engines/getnrn.py,sha256=go95qPZLTx-HI3p61zRWjey-YKlb8x7rJkXKAQcXs0k,2025
+omv/engines/getoctave.py,sha256=GvNyE_4vqYkSPfhfvco3NuVBR3P8lvIaaR42R8fLAtU,231
+omv/engines/getpylems.py,sha256=0D8otZ_iE6bwICDm1QMkdOeMSU4cfFGkPbwm2SOH37k,301
+omv/engines/getpyneuroml.py,sha256=X16_GQftMwEQsLTRU8b85Pd8L9LRay7jPkFXyhuxZbI,382
+omv/engines/getpynn.py,sha256=Ykk2e5fi4RBWJcbrvntUqXU_VySibtOg36lJkBtV5iI,1342
+omv/engines/jlems.py,sha256=WxSjJhlV3AQMPHWsGCrdPCUO_hO3SACk0mPNtq8tKcI,1604
+omv/engines/jneuroml.py,sha256=uxxZaQCAG2p8Oi2V-O2RQUX1PJbQtmpIy1YrtNRp6Io,3412
+omv/engines/jneuromlbrian.py,sha256=zpdSzjrjQbJdIH_NCwam89xLk9zIz30SlViTk9SO6e4,2379
+omv/engines/jneuromlbrian2.py,sha256=WqGuuXaEpcW1vgaW_b9vus_i3df_40iwjs3njApkf2Q,2351
+omv/engines/jneuromleden.py,sha256=uRdlTGxg9RbVw-DlLtlmKRx1i3GHrYcdCJ9SnUv0R_U,2285
+omv/engines/jneuromlmoose.py,sha256=6CyuJKuZ4T7W30GchRQHsJLTltSITAQwPXcZSuIgPsk,2323
+omv/engines/jneuromlnetpyne.py,sha256=zBOK-WcnkzCCNA1ZU_Btz7Pd8Ljh5pDL7IbwJVmHYgk,2704
+omv/engines/jneuromlnetpyne_np2.py,sha256=w_jdkS_5hn92pO0JCfR2Pw6V6chgCPhBusv1VqjbFek,1622
+omv/engines/jneuromlnetpyne_np4.py,sha256=R4wH-611YzGozA0cQwg6xB62aeM5g4KTE9sctAdlNQc,1622
+omv/engines/jneuromlnrn.py,sha256=N6gavalu0IvF4mYKJbYbCv9aNUbTjcdUSylmE5fOg_I,2741
+omv/engines/jneuromlpynnnrn.py,sha256=kq6wXkXWHyb1CrHbLelafC3NedzF8UYQSkfKsdofFfA,2734
+omv/engines/jneuromlvalidate.py,sha256=aiFUDPkdatiCyYD93IBeYpuA6zG-ZLpyAnN4qsufe3U,2016
+omv/engines/jneuromlvalidatev1.py,sha256=PrvuNa9T4rqZ-uKFc6IUXOHKxjeVqAqLs74y0sVilg4,1736
+omv/engines/moose_.py,sha256=cjql6L0bW42m6KeZ_Fj84FZ88x5Xly63eEhxBioPJXg,2731
+omv/engines/nestsli.py,sha256=qdKl_B-0HZVBqWaBNoRKb3ksz1WRlZ49Z6AvE9v_Ih8,2573
+omv/engines/netpyne_.py,sha256=Fd-kf2Ehdjp702HmC0KlYniFOFyk6t33-8QJJSQqtOI,4007
+omv/engines/netpyne__np2.py,sha256=57RbGs3xF3yBoqfQSEzvzquqziF5hBGO-XqtRKn2Z2k,1706
+omv/engines/netpyne__np4.py,sha256=-VJW_QO2tDIiQ8PgmnhZuSwp_Dq5TQg48mC0S8TL2v8,1706
+omv/engines/neuron_.py,sha256=OP3L7NS02Q5huiyc9GMIHlwienlSEVyNKOWcuZo16qU,7775
+omv/engines/octave.py,sha256=W4UIudYOXC0np1z8_-81Keb9dNz0PB7IwLZrNAYF3Zk,1558
+omv/engines/pylems.py,sha256=8P-adh3IPoGf7qr1ppq7g5avuMyg1NYFw_eu7ztW8Ps,1793
+omv/engines/pylemsnml2.py,sha256=kQz2_mL5WpQhi1F10xKF6wJa6ZSRamEzjiVXbB9EA08,1912
+omv/engines/pynest.py,sha256=FUPvn6YEvOaqROZSh5vNjh3DZc65vC2FbbuopDDkW78,3990
+omv/engines/pyneuroconstruct.py,sha256=ZKXai5wiXwyH0Z21vfqN3RWy8GtE7IZUQyfGJvNdSAk,2127
+omv/engines/pyneuroml_.py,sha256=1AWEinFnG47QaU5eQlK50Z4F1xqn3zr7bNfL0ynjW_s,1591
+omv/engines/pyneuromlvalidatesbml.py,sha256=sBYw22RhMCEm9r1aiK_KcLQGxC9WDdaLNs4CZ-N-6tE,2628
+omv/engines/pyneuron.py,sha256=LSv4hrWg3xX5555eHeGTvZcfOqnZqGppjHOhQDlrhCc,3263
+omv/engines/pynn.py,sha256=4u1TG1g3RviiILZkfsxkEY39GYaZ7Wf9hnIC2bcvT2E,1977
+omv/engines/pynnbrian1.py,sha256=aYBW8vbNxdse_AXAfK7Z2qiTd6O_vwi1J3nzMRTfyN8,2147
+omv/engines/pynnbrian2.py,sha256=I3de3ujzXyEn-4dtXg2rsN7UwVz9PLNX5OSdXj7cXes,2166
+omv/engines/pynnnest.py,sha256=u5WSj6malHYsBfegfHxkKv7H8QDJK9znhG3CG2vCNPE,1941
+omv/engines/pynnneuroml.py,sha256=z61S-l4rZUdz1i4GD15wFsEfROtiJx4WLICp3M4KmHY,1863
+omv/engines/pynnneuron.py,sha256=wMTHtvHMkoV2bqa1XfgaFzSScn0cE4khQPZLedKgnyY,3339
+omv/engines/utils/__init__.py,sha256=eCOOobo9f1a5i6i9KYNVSm4KFJXwvB_dpqjHp8pQVaM,467
+omv/engines/utils/genesis_utils.g,sha256=qMVW7OOrDISL77bNs2LZqKLNSUfLn_wOZ4rFgFPBWNc,656
+omv/engines/utils/wdir.py,sha256=brpR7ALHkc4SbzwE8gcAA-wPnWIZo9J9ezah-00Tx0Q,350
+omv/test/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omv/test/test_rates.py,sha256=14-0Vt5faXefprcBo_Dlaq33Xdpa-Z5XkHnSpD98gGU,1012
+omv/test/test_types.py,sha256=X8jg9meh44XM8uscca5xzO_S_3NZkc3WF8lVF_04Hg8,786
+omv/validation/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+omv/validation/rx_validator.py,sha256=TiT-zgc4fqoqx4BUvBBfKWKnJn5FrCv5LrAL_fRA02o,916
+omv/validation/utils.py,sha256=vDAdiaZ82LIqoDGx24o8yOgw4xP1ZA_EenrtI4xiuHE,1759
+omv/validation/validate.py,sha256=608ZX0uIMLDgJ7_VA09nh5t97dfywuaNeuTCBpATqx4,1758
+omv/validation/validate_mep.py,sha256=BXZSGNgA64vAFY5SuhbsLH7G59ULQ58gr_NTaToS1R0,380
+OSBModelValidation-0.2.18.dist-info/METADATA,sha256=zF6g5hpW6ioxW_mfKW073ENA7zGpYogRUbU3LdsslU4,10811
+OSBModelValidation-0.2.18.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+OSBModelValidation-0.2.18.dist-info/entry_points.txt,sha256=FKthTyVC1g5PLxsbjWuZSpt6SshM-j_0i2RP97lTvr0,42
+OSBModelValidation-0.2.18.dist-info/top_level.txt,sha256=6hVto0LMiELtSSMCGQNxFZpO6i5ZGdaheiuSYNpxvsk,4
+OSBModelValidation-0.2.18.dist-info/RECORD,,

OSBModelValidation-0.2.18.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.43.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

OSBModelValidation-0.2.18.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+omv = omv.omv_util:main

OSBModelValidation-0.2.18.dist-info/top_level.txt

@@ -0,0 +1 @@
+omv

omv/__init__.py

@@ -0,0 +1,8 @@
+try:
+    import importlib.metadata
+
+    __version__ = importlib.metadata.version("OSBModelValidation")
+except ImportError:
+    import importlib_metadata
+
+    __version__ = importlib_metadata.version("OSBModelValidation")

omv/analyzers/__init__.py

@@ -0,0 +1,21 @@
+from omv.analyzers.spikes import SpikeAnalyzer
+from omv.analyzers.rates import RateAnalyzer
+from omv.analyzers.dryrun import DryRunAnalyzer
+from omv.analyzers.resting import RestingAnalyzer
+from omv.analyzers.morphology import MorphologyAnalyzer
+from omv.analyzers.temperature import TemperatureAnalyzer
+from omv.analyzers.activation import ActivationVariableAnalyzer
+from omv.analyzers.input_resistance import InputResAnalyzer
+from omv.analyzers.timeseries import TimeSeriesAnalyzer
+
+OMVAnalyzers = {
+    "spike times": SpikeAnalyzer,
+    "spike rate": RateAnalyzer,
+    "dry": DryRunAnalyzer,
+    "resting": RestingAnalyzer,
+    "morphology": MorphologyAnalyzer,
+    "temperature": TemperatureAnalyzer,
+    "activation variables": ActivationVariableAnalyzer,
+    "input resistance": InputResAnalyzer,
+    "timeseries": TimeSeriesAnalyzer,
+}

omv/analyzers/activation.py

@@ -0,0 +1,24 @@
+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 ActivationVariableAnalyzer(OMVAnalyzer):
+    def parse_observable(self):
+        if "file" in self.observable:
+            f = fn.FileNodeHelper(self.observable["file"], self.omt_root)
+            inform(
+                "Activation variable from file",
+                self.observable["file"],
+                indent=1,
+                verbosity=1,
+            )
+            return f.get_timeseries()
+
+    def __call__(self):
+        obs = self.parse_observable()
+        allin = ts.all_within_bounds(obs, (0, 1))
+        if not allin:
+            inform("Activation variable outside of (0,1) interval: ", obs, indent=1)
+        return allin

omv/analyzers/analyzer.py

@@ -0,0 +1,80 @@
+from omv.analyzers.utils.timeseries import *
+from omv.common.inout import inform
+
+
+class OMVAnalyzer(object):
+    def __init__(self, observable, expected, engine, omt_root, mep_root):
+        self.engine = engine
+        self.observable = observable
+        self.expected = expected
+        self.omt_root = omt_root
+        self.mep_root = mep_root
+        self.before_running()
+
+    def before_running(self):
+        pass
+
+    def parse_expected(self):
+        pass
+
+    def parse_observable(self):
+        pass
+
+    def __call__(self):
+        try:
+            obs = self.parse_observable()
+            if obs is None:
+                inform("Could not determine observed values")
+                return False
+            if isinstance(obs, list):
+                for o in obs:
+                    if not o:
+                        inform("Could not determine observed values")
+                        return False
+
+            exp = self.parse_expected()
+
+            if exp is None:
+                inform("Could not determine expected values, value None")
+                return False
+            if isinstance(exp, list):
+                for e in exp:
+                    if not e:
+                        inform("Could not determine expected values")
+                        return False
+        except IOError as e:
+            inform(
+                "Input/output error when\
+                   checking for observable data: %s"
+                % e
+            )
+            return False
+
+        try:
+            tolerance = float(self.observable["tolerance"])
+        except (TypeError, KeyError):  # observable can be None
+            tolerance = 1e-1
+
+        are_close, best_tol = compare_arrays((obs, exp), tolerance)
+
+        if not are_close:
+            pretty_obs, pretty_exp = pretty_print_copypaste(obs, exp)
+            inform(
+                "Comparison of \n\
+                    (observed data): %s\n\
+                    and\n\
+                    (expected data): %s\n\
+                    failed against tolerance %g"
+                % (pretty_obs, pretty_exp, tolerance)
+            )
+            if best_tol:
+                inform("A better tolerance to try is: ", best_tol, indent=1)
+        else:
+            if best_tol and best_tol < tolerance:
+                inform(
+                    "Passed, but an even better tolerance might be: %s, as opposed to: %s (diff: %s)"
+                    % (best_tol, tolerance, (tolerance - best_tol)),
+                    indent=3,
+                    verbosity=1,
+                )
+        return are_close

omv/analyzers/dryrun.py

@@ -0,0 +1,13 @@
+from omv.analyzers.analyzer import OMVAnalyzer
+from omv.common.inout import inform
+
+
+class DryRunAnalyzer(OMVAnalyzer):
+    def __init__(self, ost, expected, engine, omt_root, mep_root):
+        inform(
+            "No mep file specified. Will only run simulation using: ", engine, indent=1
+        )
+        self.engine = engine
+
+    def __call__(self):
+        return not self.engine.returncode

omv/analyzers/input_resistance.py

@@ -0,0 +1,47 @@
+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 InputResAnalyzer(OMVAnalyzer):
+    """
+    Input resistance
+    """
+
+    def parseOMT(self, to_parse):
+        f = fn.FileNodeHelper(to_parse["file_Vm"], self.omt_root)
+        f_i = fn.FileNodeHelper(to_parse["file_VC_i"], self.omt_root)
+        inform(
+            "Calculating input resistance from files:",
+            (f.filename, f_i.filename),
+            indent=1,
+            verbosity=1,
+        )
+        h_voltage = to_parse.get("holding voltage", -70.0)
+        cmd_voltage = to_parse.get("command voltage", -80.0)
+        h_window = to_parse.get("holding window", [0.0, 0.0])
+        cmd_window = to_parse.get("command window", [0.0, 0.0])
+
+        # h_window = [float(t) for t in to_parse.get('holding window', [0., 0.])[0].split()]
+        # cmd_window = [float(t) for t in to_parse.get('command window', [0., 0.])[0].split()]
+        inform(
+            "Time wondow used for detection of current injections:",
+            (h_window, cmd_window),
+            indent=2,
+            verbosity=1,
+        )
+        input_resistance = ts.input_resistance(
+            f.get_timeseries(),
+            f_i.get_timeseries(),
+            h_window,
+            cmd_window,
+            (h_voltage, cmd_voltage),
+        )
+        return input_resistance
+
+    def parse_expected(self):
+        return self.expected
+
+    def parse_observable(self):
+        return self.parseOMT(self.observable)

omv/analyzers/morphology.py

@@ -0,0 +1,16 @@
+from omv.analyzers.analyzer import OMVAnalyzer
+
+
+class MorphologyAnalyzer(OMVAnalyzer):
+    def before_running(self):
+        if "total area" in self.expected:
+            base = self.observable.get("base section", "cell[0]")
+            self.query = self.engine.query_area(base)
+
+    def parse_expected(self):
+        return self.expected["total area"]
+
+    def parse_observable(self):
+        area = float(self.engine.fetch_query(self.query))
+        scale = float(self.observable.get("scaling", 1))
+        return scale * area

omv/analyzers/rates.py

@@ -0,0 +1,97 @@
+from omv.analyzers.spikes import SpikeAnalyzer
+from omv.analyzers.utils import timeseries as ts
+from omv.common.inout import inform
+from os import getcwd
+
+
+class RateAnalyzer(SpikeAnalyzer):
+    def parse_spike_rates(self, to_parse):
+        if isinstance(to_parse, float) or isinstance(to_parse, int):
+            rate = to_parse
+
+        elif "file" in to_parse or "spiketimes file" in to_parse:
+            spikes = []
+            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)
+
+                    spikes = self.f.get_spike_times()
+
+                if "method" in to_parse:
+                    method = to_parse["method"]
+                    if "start_time" in to_parse:
+                        start_time = to_parse["start_time"]
+                    else:
+                        start_time = 0
+                    if "end_time" in to_parse:
+                        end_time = to_parse["end_time"]
+                    else:
+                        end_time = float("inf")
+                    rate = ts.get_spike_rate(spikes, method, start_time, end_time)
+
+                else:
+                    rate = ts.get_spike_rate(spikes)
+            else:
+                inform(
+                    "ERROR! Preexistent datafile %s has not been updated!"
+                    % self.f.filename,
+                    indent=2,
+                    verbosity=0,
+                    underline="-",
+                )
+                rate = -1
+
+        return rate
+
+    def parse_expected(self):
+        return self.parse_spike_rates(self.expected)
+
+    def parse_observable(self):
+        return self.parse_spike_rates(self.observable)

omv/analyzers/resting.py

@@ -0,0 +1,37 @@
+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 RestingAnalyzer(OMVAnalyzer):
+    def parse_resting(self, to_parse):
+        if isinstance(to_parse, (int, float)):
+            resting = to_parse
+            inform(
+                "Explicit resting potential specified:", to_parse, indent=1, verbosity=1
+            )
+        elif "file" in to_parse:
+            f = fn.FileNodeHelper(to_parse["file"], self.omt_root)
+            inform(
+                "Calculating resting potential from file:",
+                f.filename,
+                indent=1,
+                verbosity=1,
+            )
+            window = to_parse.get("average last", 1)
+            if window > 1:
+                inform(
+                    "Number of final points taken for averaging:",
+                    window,
+                    indent=2,
+                    verbosity=1,
+                )
+            resting = ts.average_resting(f.get_timeseries(), window)
+        return resting
+
+    def parse_expected(self):
+        return self.parse_resting(self.expected)
+
+    def parse_observable(self):
+        return self.parse_resting(self.observable)