def __init__(self, regimes=None, aliases=None, state_variables=None):
"""Dynamics object constructor
:param aliases: A list of aliases, which must be either |Alias|
objects or ``string``s.
:param regimes: A list containing at least one |Regime| object.
:param state_variables: An optional list of the state variables,
which can either be |StateVariable| objects or `string` s. If
provided, it must match the inferred state-variables from the
regimes; if it is not provided it will be inferred
automatically.
"""
aliases = nineml.utility.normalise_parameter_as_list(aliases)
regimes = nineml.utility.normalise_parameter_as_list(regimes)
state_variables = nineml.utility.normalise_parameter_as_list(state_variables)
# Load the aliases as objects or strings:
from nineml.utility import filter_discrete_types
alias_td = filter_discrete_types(aliases, (basestring, Alias))
aliases_from_strs = [StrToExpr.alias(o) for o in alias_td[basestring]]
aliases = alias_td[Alias] + aliases_from_strs
# Load the state variables as objects or strings:
sv_types = (basestring, StateVariable)
sv_td = filter_discrete_types(state_variables, sv_types)
sv_from_strings = [StateVariable(o) for o in sv_td[basestring]]
state_variables = sv_td[StateVariable] + sv_from_strings
self._regimes = regimes
self._aliases = aliases
self._state_variables = state_variables
def expr_to_obj(s, name=None):
""" Construct nineml objects from expressions """
from util import StrToExpr
# import re
# Is our job already done?
if isinstance(s, (RegimeElement)):
return s
# strip surrounding whitespace
s = s.strip()
# Do we have a alias?
if StrToExpr.is_alias(s):
return StrToExpr.alias(s)
# re for an expression -> groups into lhs, op, rhs
p_eqn = re.compile(
r"(?P<lhs>[a-zA-Z_]+[a-zA-Z_0-9]*(/?[a-zA-Z_]+[a-zA-Z_0-9]*)?)\s*(?P<op>[+\-*/:]?=)\s*(?P<rhs>.*)")
m = p_eqn.match(s)
if not m:
raise ValueError, "Not a valid nineml expression: %s" % s
# get lhs, op, rhs
lhs, op, rhs = [m.group(x) for x in ['lhs', 'op', 'rhs']]
# do we have an TimeDerivative?
# re for lhs for TimeDerivative
p_ode_lhs = re.compile(r"(?:d)([a-zA-Z_]+[a-zA-Z_0-9]*)/(?:d)([a-zA-Z_]+[a-zA-Z_0-9]*)")
m = p_ode_lhs.match(lhs)
if m:
if op != "=":
raise ValueError, "TimeDerivative lhs, but op not '=' in %s" % s
dep_var = m.group(1)
indep_var = m.group(2)
return TimeDerivative(dep_var, indep_var, rhs, name=name)
# Do we have an Inplace op?
# if op in Inplace.op_name_map.keys():
# return Inplace(lhs,op,rhs, name = name)
# Do we have an assignment?
if op == "=":
return StateAssignment(lhs, rhs, name=name)
# If we get here, what do we have?
raise ValueError, "Cannot map expr '%s' to a nineml Expression" % s
