OSBModelValidation 0.2.18__py3-none-any.whl

omv/engines/jneuroml.py

@@ -0,0 +1,101 @@
+import os
+import shutil
+import subprocess as sp
+from pathlib import Path
+import platform
+
+from omv.common.inout import inform, trim_path, is_verbose, check_output
+from omv.engines.engine import OMVEngine, EngineExecutionError
+
+
+class JNeuroMLEngine(OMVEngine):
+    name = "jNeuroML"
+
+    @staticmethod
+    def get_environment():
+        if "JNML_HOME" in os.environ:
+            jnmlhome = os.environ["JNML_HOME"]
+        elif shutil.which("jnml") is not None:
+            jnmlhome = Path(shutil.which("jnml")).parent
+        else:
+            osname = platform.system()
+            if osname == "Linux":
+                try:
+                    jnmlhome = os.path.join(
+                        os.environ["XDG_DATA_HOME"], "jnml/jNeuroMLJar"
+                    )
+                except KeyError as e:
+                    localsharepath = os.path.join(os.environ["HOME"], ".local/share")
+                    if os.path.isdir(localsharepath):
+                        jnmlhome = os.path.join(
+                            os.environ["HOME"], ".local/share/jnml/jNeuroMLJar"
+                        )
+                    else:
+                        jnmlhome = os.path.join(os.environ["HOME"], "jnml/jNeuroMLJar")
+
+            elif osname == "Darwin":
+                jnmlhome = os.path.join(os.environ["HOME"], "Library/jnml/jNeuroMLJar")
+            else:
+                jnmlhome = os.path.join(os.environ["HOME"], "jnml/jNeuroMLJar")
+
+        environment_vars = {"JNML_HOME": jnmlhome}
+
+        return environment_vars
+
+    @staticmethod
+    def get_executable():
+        environment_vars = JNeuroMLEngine.get_environment()
+        jnml = os.path.join(
+            environment_vars["JNML_HOME"], "jnml" if os.name != "nt" else "jnml.bat"
+        )
+        return jnml
+
+    @staticmethod
+    def is_installed():
+        ret = True
+        try:
+            if is_verbose():
+                inform(
+                    "Checking whether %s is installed..." % JNeuroMLEngine.name,
+                    indent=1,
+                )
+            FNULL = open(os.devnull, "w")
+            jnml = JNeuroMLEngine.get_executable()
+            r = check_output(
+                [jnml, "-v"], verbosity=2, env=JNeuroMLEngine.get_environment()
+            )
+            ret = "%s" % r.split()[1]
+
+            if is_verbose():
+                inform("%s %s is installed..." % (JNeuroMLEngine.name, ret), indent=2)
+        except OSError as err:
+            if is_verbose():
+                inform("Couldn't execute/import jNeuroML: ", err, indent=1)
+            ret = False
+        return ret
+
+    @staticmethod
+    def install(version):
+        from omv.engines.getjnml import install_jnml
+
+        inform("Will fetch and install jNeuroML jar", indent=2)
+        install_jnml(version)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s" % (trim_path(self.modelpath), self.name),
+                indent=1,
+            )
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = sp.check_output(
+                [jnml, self.modelpath, "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlbrian.py

@@ -0,0 +1,65 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.brian1 import Brian1Engine
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLBrianEngine(JNeuroMLEngine):
+    name = "jNeuroML_Brian"
+
+    python3_compatible = Brian1Engine.python3_compatible
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLBrianEngine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and Brian1Engine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+        if not Brian1Engine.is_installed():
+            Brian1Engine.install(None)
+
+        JNeuroMLBrianEngine.path = JNeuroMLEngine.path + ":" + Brian1Engine.path
+        JNeuroMLBrianEngine.environment_vars = {}
+        JNeuroMLBrianEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLBrianEngine.environment_vars.update(Brian1Engine.environment_vars)
+        inform("PATH: " + JNeuroMLBrianEngine.path)
+        inform("Env vars: %s" % JNeuroMLBrianEngine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLBrianEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-brian"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            self.stdout += check_output(
+                ["python", self.modelpath.replace(".xml", "_brian.py"), "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            inform("Success with running ", JNeuroMLBrianEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLBrianEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlbrian2.py

@@ -0,0 +1,61 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.brian2_ import Brian2Engine
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLBrian2Engine(JNeuroMLEngine):
+    name = "jNeuroML_Brian2"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLBrian2Engine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and Brian2Engine.is_installed()
+
+    @staticmethod
+    def install(brian2_version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+        if not Brian2Engine.is_installed():
+            Brian2Engine.install(brian2_version)
+
+        JNeuroMLBrian2Engine.path = JNeuroMLEngine.path + ":" + Brian2Engine.path
+        JNeuroMLBrian2Engine.environment_vars = {}
+        JNeuroMLBrian2Engine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLBrian2Engine.environment_vars.update(Brian2Engine.environment_vars)
+        inform("PATH: " + JNeuroMLBrian2Engine.path)
+        inform("Env vars: %s" % JNeuroMLBrian2Engine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLBrian2Engine.name),
+                indent=1,
+            )
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-brian2"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            self.stdout += check_output(
+                ["python", self.modelpath.replace(".xml", "_brian2.py"), "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            inform("Success with running ", JNeuroMLBrian2Engine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLBrian2Engine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromleden.py

@@ -0,0 +1,61 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.eden_ import EdenEngine
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLEdenEngine(JNeuroMLEngine):
+    name = "jNeuroML_EDEN"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLEdenEngine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and EdenEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+        if not EdenEngine.is_installed():
+            EdenEngine.install(version)
+
+        JNeuroMLEdenEngine.path = JNeuroMLEngine.path + ":" + EdenEngine.path
+        JNeuroMLEdenEngine.environment_vars = {}
+        JNeuroMLEdenEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLEdenEngine.environment_vars.update(EdenEngine.environment_vars)
+        inform("PATH: " + JNeuroMLEdenEngine.path)
+        inform("Env vars: %s" % JNeuroMLEdenEngine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLEdenEngine.name),
+                indent=1,
+            )
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-eden"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            self.stdout += check_output(
+                ["python", self.modelpath.replace(".xml", "_eden.py")],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            inform("Success with running ", JNeuroMLEdenEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLEdenEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlmoose.py

@@ -0,0 +1,63 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.moose_ import MooseEngine
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLMooseEngine(JNeuroMLEngine):
+    name = "jNeuroML_Moose"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLMooseEngine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and MooseEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+        if not MooseEngine.is_installed():
+            MooseEngine.install(None)
+
+        JNeuroMLMooseEngine.path = JNeuroMLEngine.path + ":" + JNeuroMLMooseEngine.path
+        JNeuroMLMooseEngine.environment_vars = {}
+        JNeuroMLMooseEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLMooseEngine.environment_vars.update(MooseEngine.environment_vars)
+        inform("PATH: " + JNeuroMLMooseEngine.path)
+        inform("Env vars: %s" % JNeuroMLMooseEngine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLMooseEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-moose"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            self.stdout += check_output(
+                ["python", self.modelpath.replace(".xml", "_moose.py"), "-nogui"],
+                cwd=os.path.dirname(self.modelpath),
+            )
+            inform("Success with running ", JNeuroMLMooseEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLMooseEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlnetpyne.py

@@ -0,0 +1,73 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.netpyne_ import NetPyNEEngine
+from omv.engines.neuron_ import NeuronEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLNetPyNEEngine(JNeuroMLEngine):
+    name = "jNeuroML_NetPyNE"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLNetPyNEEngine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and NetPyNEEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+            inform(
+                "%s installed JNeuroML..." % JNeuroMLNetPyNEEngine.name,
+                indent=2,
+                verbosity=1,
+            )
+        if not NetPyNEEngine.is_installed():
+            NetPyNEEngine.install(None)
+            inform(
+                "%s installed NetPyNE (& NEURON)..." % JNeuroMLNetPyNEEngine.name,
+                indent=2,
+                verbosity=1,
+            )
+
+        environment_vars_nrn, path_nrn = NeuronEngine.get_nrn_environment()
+
+        JNeuroMLNetPyNEEngine.path = JNeuroMLEngine.path + ":" + path_nrn
+        JNeuroMLNetPyNEEngine.environment_vars = {}
+        JNeuroMLNetPyNEEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLNetPyNEEngine.environment_vars.update(NetPyNEEngine.environment_vars)
+        JNeuroMLNetPyNEEngine.environment_vars.update(environment_vars_nrn)
+        inform("PATH: " + JNeuroMLNetPyNEEngine.path)
+        inform("Env vars: %s" % JNeuroMLNetPyNEEngine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLNetPyNEEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-netpyne", "-nogui", "-run"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform("Success with running ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlnetpyne_np2.py

@@ -0,0 +1,45 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuromlnetpyne import JNeuroMLNetPyNEEngine
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import EngineExecutionError
+
+"""
+    A temporary engine for testing running jNeuroML_NetPyNE models in parallel mode.
+    Would require update of NEURON installation process to ensure parallel 
+    NEURON correctly installed, so mainly useful for local testing presently.
+    Would also be better to incorporate this into netpyne_.py, and have correct 
+    handling of variables specified in *.omt files
+"""
+
+
+class JNeuroMLNetPyNENP2Engine(JNeuroMLNetPyNEEngine):
+    name = "jNeuroML_NetPyNE_NP2"
+
+    def run(self):
+        np = 2
+
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLNetPyNEEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-netpyne", "-nogui", "-run", "-np", "%s" % np],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform("Success with running ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlnetpyne_np4.py

@@ -0,0 +1,45 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuromlnetpyne import JNeuroMLNetPyNEEngine
+
+from omv.common.inout import inform, trim_path, check_output
+from omv.engines.engine import EngineExecutionError
+
+"""
+    A temporary engine for testing running jNeuroML_NetPyNE models in parallel mode.
+    Would require update of NEURON installation process to ensure parallel 
+    NEURON correctly installed, so mainly useful for local testing presently.
+    Would also be better to incorporate this into netpyne_.py, and have correct 
+    handling of variables specified in *.omt files
+"""
+
+
+class JNeuroMLNetPyNENP4Engine(JNeuroMLNetPyNEEngine):
+    name = "jNeuroML_NetPyNE_NP4"
+
+    def run(self):
+        np = 4
+
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLNetPyNEEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-netpyne", "-nogui", "-run", "-np", "%s" % np],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform("Success with running ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLNetPyNEEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError

omv/engines/jneuromlnrn.py

@@ -0,0 +1,78 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.neuron_ import NeuronEngine
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLNRNEngine(JNeuroMLEngine):
+    name = "jNeuroML_NEURON"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLNRNEngine.name, indent=1
+            )
+        return JNeuroMLEngine.is_installed() and NeuronEngine.is_installed()
+
+    @staticmethod
+    def install(nrn_version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+        if not NeuronEngine.is_installed():
+            NeuronEngine.install(nrn_version)
+
+        JNeuroMLNRNEngine.get_jnmlnrnenv()
+
+    @staticmethod
+    def get_jnmlnrnenv():
+        environment_vars_nrn, path_nrn = NeuronEngine.get_nrn_environment()
+
+        JNeuroMLNRNEngine.path = JNeuroMLEngine.path + ":" + path_nrn
+        JNeuroMLNRNEngine.environment_vars = {}
+        JNeuroMLNRNEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLNRNEngine.environment_vars.update(environment_vars_nrn)
+
+        JNeuroMLNRNEngine.environment_vars.update(JNeuroMLEngine.get_environment())
+
+        inform("PATH: " + JNeuroMLNRNEngine.path)
+        inform("Env vars: %s" % JNeuroMLNRNEngine.environment_vars)
+        del JNeuroMLNRNEngine.environment_vars["PYTHONPATH"]
+
+        return JNeuroMLNRNEngine.environment_vars
+
+    def run(self):
+        self.stdout, self.returncode = JNeuroMLNRNEngine.run_using_jnmlnrn_env(
+            JNeuroMLNRNEngine.name, self.modelpath, ["-neuron", "-nogui", "-run"]
+        )
+
+        if self.returncode != 0:
+            raise EngineExecutionError
+
+    @staticmethod
+    def run_using_jnmlnrn_env(engine, modelpath, args):
+        try:
+            env = JNeuroMLNRNEngine.get_jnmlnrnenv()
+            inform(
+                "Running file %s with %s, env: %s"
+                % (trim_path(modelpath), engine, env),
+                indent=1,
+            )
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+            cmds = [jnml, modelpath]
+            cmds.extend(args)
+            stdout = check_output(cmds, cwd=os.path.dirname(modelpath), env=env)
+
+            inform("Success with running ", engine, indent=1)
+            returncode = 0
+            return stdout, returncode
+        except sp.CalledProcessError as err:
+            inform("Error with ", engine, indent=1)
+            returncode = err.returncode
+            stdout = err.output
+            return stdout, returncode

omv/engines/jneuromlpynnnrn.py

@@ -0,0 +1,75 @@
+import os
+import subprocess as sp
+
+from omv.engines.jneuroml import JNeuroMLEngine
+from omv.engines.pynnneuron import PyNNNRNEngine
+from omv.engines.neuron_ import NeuronEngine
+from omv.engines.pynn import PyNNEngine
+
+from omv.common.inout import inform, trim_path, check_output, is_verbose
+from omv.engines.engine import EngineExecutionError
+
+
+class JNeuroMLPyNNNRNEngine(JNeuroMLEngine):
+    name = "jNeuroML_PyNN_NEURON"
+
+    @staticmethod
+    def is_installed():
+        if is_verbose():
+            inform(
+                "Checking whether %s is installed..." % JNeuroMLPyNNNRNEngine.name,
+                indent=1,
+            )
+        return JNeuroMLEngine.is_installed() and PyNNNRNEngine.is_installed()
+
+    @staticmethod
+    def install(version):
+        if not JNeuroMLEngine.is_installed():
+            JNeuroMLEngine.install(None)
+            inform(
+                "%s installed JNeuroML..." % JNeuroMLPyNNNRNEngine.name,
+                indent=2,
+                verbosity=1,
+            )
+        if not PyNNNRNEngine.is_installed():
+            PyNNNRNEngine.install(None)
+            inform(
+                "%s installed PyNN & NRN..." % JNeuroMLPyNNNRNEngine.name,
+                indent=2,
+                verbosity=1,
+            )
+
+        environment_vars_nrn, path_nrn = NeuronEngine.get_nrn_environment()
+
+        JNeuroMLPyNNNRNEngine.path = JNeuroMLEngine.path + ":" + path_nrn
+        JNeuroMLPyNNNRNEngine.environment_vars = {}
+        JNeuroMLPyNNNRNEngine.environment_vars.update(JNeuroMLEngine.environment_vars)
+        JNeuroMLPyNNNRNEngine.environment_vars.update(PyNNEngine.environment_vars)
+        JNeuroMLPyNNNRNEngine.environment_vars.update(environment_vars_nrn)
+        inform("PATH: " + JNeuroMLPyNNNRNEngine.path)
+        inform("Env vars: %s" % JNeuroMLPyNNNRNEngine.environment_vars)
+
+    def run(self):
+        try:
+            inform(
+                "Running file %s with %s"
+                % (trim_path(self.modelpath), JNeuroMLPyNNNRNEngine.name),
+                indent=1,
+            )
+
+            from omv.engines.jneuroml import JNeuroMLEngine
+
+            jnml = JNeuroMLEngine.get_executable()
+
+            self.stdout = check_output(
+                [jnml, self.modelpath, "-pynn", "-run-neuron"],
+                cwd=os.path.dirname(self.modelpath),
+                env=JNeuroMLEngine.get_environment(),
+            )
+            inform("Success with running ", JNeuroMLPyNNNRNEngine.name, indent=1)
+            self.returncode = 0
+        except sp.CalledProcessError as err:
+            inform("Error with ", JNeuroMLPyNNNRNEngine.name, indent=1)
+            self.returncode = err.returncode
+            self.stdout = err.output
+            raise EngineExecutionError