def __init__(self, regimes=None, aliases=None, state_variables=None):
"""DynamicsBlock 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 = normalise_parameter_as_list(aliases)
regimes = normalise_parameter_as_list(regimes)
state_variables = normalise_parameter_as_list(state_variables)
# Load the aliases as objects or strings:
alias_td = filter_discrete_types(aliases, (basestring, Alias))
aliases_from_strs = [Alias.from_str(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, dimension=None) for o in sv_td[basestring]
]
state_variables = sv_td[StateVariable] + sv_from_strings
assert_no_duplicates(r.name for r in regimes)
assert_no_duplicates(a.lhs for a in aliases)
assert_no_duplicates(s.name for s in state_variables)
self._regimes = dict((r.name, r) for r in regimes)
self._aliases = dict((a.lhs, a) for a in aliases)
self._state_variables = dict((s.name, s) for s in state_variables)
def __init__(self, regimes=None, aliases=None, state_variables=None):
"""DynamicsBlock 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 = normalise_parameter_as_list(aliases)
regimes = normalise_parameter_as_list(regimes)
state_variables = normalise_parameter_as_list(state_variables)
# Load the aliases as objects or strings:
alias_td = filter_discrete_types(aliases, (basestring, Alias))
aliases_from_strs = [Alias.from_str(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, dimension=None)
for o in sv_td[basestring]]
state_variables = sv_td[StateVariable] + sv_from_strings
assert_no_duplicates(r.name for r in regimes)
assert_no_duplicates(a.lhs for a in aliases)
assert_no_duplicates(s.name for s in state_variables)
self._regimes = dict((r.name, r) for r in regimes)
self._aliases = dict((a.lhs, a) for a in aliases)
self._state_variables = dict((s.name, s) for s in state_variables)
def __init__(self, *args, **kwargs):
"""Regime constructor
:param name: The name of the constructor. If none, then a name will
be automatically generated.
:param time_derivatives: A list of time derivatives, as
either ``string``s (e.g 'dg/dt = g/gtau') or as
|TimeDerivative| objects.
:param transitions: A list containing either |OnEvent| or
|OnCondition| objects, which will automatically be sorted into
the appropriate classes automatically.
:param *args: Any non-keyword arguments will be treated as
time_derivatives.
"""
valid_kwargs = ('name', 'transitions', 'time_derivatives')
for arg in kwargs:
if arg not in valid_kwargs:
err = 'Unexpected Arg: %s' % arg
raise NineMLRuntimeError(err)
transitions = kwargs.get('transitions', None)
name = kwargs.get('name', None)
kw_tds = normalise_parameter_as_list(kwargs.get('time_derivatives',
None))
time_derivatives = list(args) + kw_tds
self._name = name
if self.name is not None:
self._name = self._name.strip()
ensure_valid_identifier(self._name)
# Un-named arguments are time_derivatives:
time_derivatives = normalise_parameter_as_list(time_derivatives)
# time_derivatives.extend( args )
td_types = (basestring, TimeDerivative)
td_type_dict = filter_discrete_types(time_derivatives, td_types)
td_from_str = [TimeDerivative.from_str(o)
for o in td_type_dict[basestring]]
time_derivatives = td_type_dict[TimeDerivative] + td_from_str
# Check for double definitions:
td_dep_vars = [td.dependent_variable for td in time_derivatives]
assert_no_duplicates(td_dep_vars)
# Store as a dictionary
self._time_derivatives = dict((td.dependent_variable, td)
for td in time_derivatives)
# We support passing in 'transitions', which is a list of both OnEvents
# and OnConditions. So, lets filter this by type and add them
# appropriately:
transitions = normalise_parameter_as_list(transitions)
f_dict = filter_discrete_types(transitions, (OnEvent, OnCondition))
self._on_events = []
self._on_conditions = []
# Add all the OnEvents and OnConditions:
for event in f_dict[OnEvent]:
self.add_on_event(event)
for condition in f_dict[OnCondition]:
self.add_on_condition(condition)
# Sort for equality checking
self._on_events = sorted(self._on_events,
key=lambda x: x.src_port_name)
self._on_conditions = sorted(self._on_conditions,
key=lambda x: x.trigger)
