myokit 1.37.1__py3-none-any.whl → 1.37.3__py3-none-any.whl

myokit/formats/sbml/_api.py

@@ -5,11 +5,13 @@
 # See http://myokit.org for copyright, sharing, and licensing details.
 #
 import collections
+from typing import Dict
 import warnings
 import re
 
 import myokit
 import myokit.units
+from myokit.formats.cellml.v2._api import create_unit_name as cellml_create_unit_name  # noqa: E501
 
 
 # Regex for id checking
@@ -156,6 +158,7 @@ class Compartment(Quantity):
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._size_units = units
+        self._model.add_unit_if_possible(units)
 
     def sid(self):
         """Returns this compartment's sid."""
@@ -247,6 +250,99 @@ class Model:
         # CSymbolVariable for time
         self._time = CSymbolVariable(_SBML_TIME)
 
+    @staticmethod
+    def create_unit_name(unit):
+        if unit in Model._base_units_reverse:
+            return Model._base_units_reverse[unit]
+        return cellml_create_unit_name(unit)
+
+    @staticmethod
+    def from_myokit_model(model: myokit.Model) -> 'Model':
+        """
+        Creates an SBML model from a :class:`myokit.Model`.
+        """
+        # Model must be valid
+        # Otherwise could have cycles, invalid references, etc.
+        model.validate()
+
+        # Get name for model
+        name = model.name()
+        if name is None:
+            name = 'unnamed_myokit_model'
+
+        # Create model
+        m = Model(name)
+
+        # Valid model always has a time variable
+        time = model.time()
+
+        # Method to obtain or infer variable unit
+        def variable_unit(variable, time_unit):
+            """Returns variable.unit(), or attempts to infer it if not set."""
+            unit = variable.unit()
+            if unit is not None:
+                return unit
+
+            rhs = variable.rhs()
+            if rhs is not None:
+                try:
+                    # If unit not set try to infer from the rhs.
+                    # Result may be None.
+                    unit = rhs.eval_unit(myokit.UNIT_TOLERANT)
+                except myokit.IncompatibleUnitError:
+                    return None
+                if variable.is_state():
+                    if unit is not None and time_unit is not None:
+                        # RHS is divided by time unit, so multiply
+                        unit *= time_unit
+            return unit
+
+        # Time unit, used to infer units of state variables
+        # (May itself be inferred)
+        time_unit = variable_unit(time, None)
+        if time_unit is not None:
+            m.set_time_units(time_unit)
+
+        # Create unames in model for nested variables
+        model.create_unique_names()
+
+        def add_variable(variable: myokit.Variable):
+            if variable is time:
+                return
+            v = m.add_parameter(
+                variable.uname(),
+                variable.is_constant(),
+            )
+            if variable.is_state() or variable.is_literal():
+                v.set_value(variable.rhs(), variable.is_state())
+            else:
+                # if variable is constant but not literal,
+                # set via initial value
+                v.set_initial_value(variable.rhs())
+
+            if variable.is_state():
+                v.set_initial_value(variable.initial_value())
+
+            unit = variable_unit(variable, time_unit)
+            if unit is not None:
+                v.set_units(unit)
+
+        # Add variables
+        for component in model:
+            for variable in component:
+                # Get variable unit, or infer from RHS if None
+                unit = variable_unit(variable, time_unit)
+
+                # Add variable
+                add_variable(variable)
+
+                # Add nested variables
+                for nested in variable.variables(deep=True):
+                    add_variable(nested)
+
+        # Return model
+        return m
+
     def add_compartment(self, sid):
         """Adds a :class:`myokit.formats.sbml.Compartment` to this model."""
 
@@ -258,17 +354,21 @@ class Model:
         self._assignables[sid] = c
         return c
 
-    def add_parameter(self, sid):
+    def add_parameter(self, sid, is_constant=True):
         """Adds a :class:`myokit.formats.sbml.Parameter` to this model."""
 
         sid = str(sid)
 
         self._register_sid(sid)
-        p = Parameter(self, sid)
+        p = Parameter(self, sid, is_constant)
         self._parameters[sid] = p
         self._assignables[sid] = p
         return p
 
+    def parameters(self):
+        """Returns a list of all parameters in this model."""
+        return list(self._parameters.values())
+
     def add_reaction(self, sid):
         """Adds a :class:`myokit.formats.sbml.Reaction` to this model."""
         self._register_sid(sid)
@@ -296,11 +396,24 @@ class Model:
 
         return s
 
+    def add_unit_if_possible(self, unit):
+        """
+        Adds a unit to the model if it's not already present or in the set
+        of base units, and returns the unit's name.
+        """
+        unitsid = Model.create_unit_name(unit)
+        if unitsid in self.base_units or unitsid == 'celsius':
+            return
+        if unitsid in self._units:
+            return
+        self.add_unit(unitsid, unit)
+        return unitsid
+
     def add_unit(self, unitsid, unit):
         """Adds a user unit with the given ``unitsid`` and myokit ``unit``."""
         if not _re_id.match(unitsid):
             raise SBMLError('Invalid UnitSId "' + str(unitsid) + '".')
-        if unitsid in self._base_units or unitsid == 'celsius':
+        if unitsid in self.base_units or unitsid == 'celsius':
             raise SBMLError(
                 'User unit overrides built-in unit: "' + str(unitsid) + '".')
         if unitsid in self._units:
@@ -350,7 +463,7 @@ class Model:
 
         try:
             # Find and return
-            return self._base_units[unitsid]
+            return self.base_units[unitsid]
         except KeyError:
             raise SBMLError(
                 '<' + unitsid + '> is not an SBML base unit.')
@@ -359,6 +472,10 @@ class Model:
         """Returns the compartment with the given sid."""
         return self._compartments[sid]
 
+    def compartments(self):
+        """Returns a list of all compartments in this model."""
+        return list(self._compartments.values())
+
     def conversion_factor(self):
         """
         Returns the :class:`Parameter` acting as global species conversion
@@ -424,6 +541,7 @@ class Model:
         Sets the default compartment size units for 2-dimensional compartments.
         """
         self._area_units = units
+        self.add_unit_if_possible(units)
 
     def set_conversion_factor(self, factor):
         """
@@ -447,6 +565,7 @@ class Model:
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._extent_units = units
+        self.add_unit_if_possible(units)
 
     def set_length_units(self, units):
         """
@@ -457,6 +576,7 @@ class Model:
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._length_units = units
+        self.add_unit_if_possible(units)
 
     def set_notes(self, notes=None):
         """Sets an optional notes string for this model."""
@@ -469,6 +589,7 @@ class Model:
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._substance_units = units
+        self.add_unit_if_possible(units)
 
     def set_time_units(self, units):
         """Sets the time units used throughout the model."""
@@ -477,6 +598,7 @@ class Model:
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._time_units = units
+        self.add_unit_if_possible(units)
 
     def set_volume_units(self, units):
         """
@@ -487,6 +609,7 @@ class Model:
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._volume_units = units
+        self.add_unit_if_possible(units)
 
     def __str__(self):
         if self._name is None:
@@ -497,6 +620,14 @@ class Model:
         """Returns the species with the given id."""
         return self._species[sid]
 
+    def species_list(self):
+        """ returns a list of all species in this model."""
+        return list(self._species.values())
+
+    def reactions(self):
+        """Returns a list of all reactions in this model."""
+        return list(self._reactions.values())
+
     def substance_units(self):
         """
         Returns the default units for reaction amounts (not concentrations), or
@@ -514,6 +645,14 @@ class Model:
         """Returns the default units for time, or dimensionless if not set."""
         return self._time_units
 
+    def units(self) -> Dict[str, myokit.Unit]:
+        """Returns a dict mapping sid to unit for all units in this model."""
+        return dict(self._units)
+
+    def has_units(self) -> bool:
+        """Returns ``True`` if this model has any units defined."""
+        return bool(self._units)
+
     def unit(self, unitsid):
         """Returns a user-defined or predefined unit."""
         try:
@@ -534,7 +673,7 @@ class Model:
         return self._volume_units
 
     # SBML base units (except Celsius, because it's not defined in myokit)
-    _base_units = {
+    base_units = {
         'ampere': myokit.units.A,
         'avogadro': myokit.parse_unit('1 (6.02214179e23)'),
         'becquerel': myokit.units.Bq,
@@ -572,6 +711,10 @@ class Model:
         'weber': myokit.units.Wb,
     }
 
+    _base_units_reverse = {
+        v: k for k, v in base_units.items()
+    }
+
 
 class Parameter(Quantity):
     """
@@ -586,7 +729,7 @@ class Parameter(Quantity):
         This parameter's SId.
 
     """
-    def __init__(self, model, sid):
+    def __init__(self, model, sid, is_constant=True):
         super().__init__()
 
         if not isinstance(model, Model):
@@ -595,6 +738,7 @@ class Parameter(Quantity):
                 ' myokit.formats.sbml.Model.')
 
         self._model = model
+        self._is_constant = is_constant
         self._sid = str(sid)
         self._units = None
 
@@ -605,6 +749,15 @@ class Parameter(Quantity):
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._units = units
+        self._model.add_unit_if_possible(units)
+
+    def is_constant(self):
+        """Returns ``True`` if this parameter is constant, else ``False``."""
+        return self._is_constant
+
+    def is_literal(self):
+        """Returns ``True`` if this parameter is a literal value."""
+        return self.is_constant() and self._value is not None
 
     def sid(self):
         """Returns this parameter's sid."""
@@ -889,6 +1042,7 @@ class Species(Quantity):
                 '<' + str(units) + '> needs to be instance of myokit.Unit')
 
         self._units = units
+        self._compartment._model.add_unit_if_possible(units)
 
     def sid(self):
         """Returns this species's sid."""

myokit/formats/sbml/_exporter.py

@@ -0,0 +1,53 @@
+#
+# Exports to SBML.
+#
+# This file is part of Myokit.
+# See http://myokit.org for copyright, sharing, and licensing details.
+#
+import warnings
+
+import myokit
+from myokit.formats.sbml._writer import write_file
+import myokit.lib.guess
+import myokit.formats.sbml as sbml
+
+
+class SBMLExporter(myokit.formats.Exporter):
+    """
+    This :class:`Exporter<myokit.formats.Exporter>` creates an SBML model.
+    """
+
+    def __init__(self):
+        super().__init__()
+
+    def model(self, path, model, protocol=None):
+        """
+        Writes an SBML model to the given filename.
+
+        Arguments:
+
+        ``path``
+            The path/filename to write the generated code to.
+        ``model``
+            The model to export.
+        ``protocol``
+            If given, an attempt will be made to convert the protocol to an
+            expression and insert it into the model before exporting. See
+            :meth:`myokit.lib.guess.add_embedded_protocol()` for details.
+
+        """
+        # Embed protocol
+        if protocol is not None:
+            model = model.clone()
+            if not myokit.lib.guess.add_embedded_protocol(model, protocol):
+                warnings.warn("Unable to embed stimulus protocol.")
+
+        # Export
+        sbml_model = sbml.Model.from_myokit_model(model)
+        write_file(path, sbml_model)
+
+    def supports_model(self):
+        """
+        Returns ``True``.
+        """
+        return True