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 not arg 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
# Generate a name for unnamed regions:
self._name = name.strip() if name else Regime.get_next_name()
ensure_valid_c_variable_name(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 = [StrToExpr.time_derivative(o)
for o in td_type_dict[basestring]]
self._time_derivatives = td_type_dict[TimeDerivative] + td_from_str
# Check for double definitions:
td_dep_vars = [td.dependent_variable for td in self._time_derivatives]
assert_no_duplicates(td_dep_vars)
# 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)
def __init__(self, name, dimension=""):
"""StateVariable Constructor
:param name: The name of the state variable.
"""
self._name = name.strip()
self._dimension = dimension
ensure_valid_c_variable_name(self._name)
def __init__(self, name):
""" Port Constructor.
:param name: The name of the port, as a `string`
"""
name = name.strip()
ensure_valid_c_variable_name(name)
self._name = name
def __init__(self, analog_ports=None,
event_ports=None, dynamics=None):
"""Constructor - For parameter descriptions, see the
ComponentClass.__init__() method
"""
self._analog_ports = analog_ports or []
self._event_ports = event_ports or []
self._dynamics = dynamics
ensure_valid_c_variable_name(self.name)
def __init__(self, name, dimension=""):
"""Parameter Constructor
:param name: The name of the parameter.
"""
name = name.strip()
ensure_valid_c_variable_name(name)
self._name = name
self._dimension = dimension
def __init__(self, name, dimension="", valid_range=None):
"""Parameter Constructor
:param name: The name of the parameter.
"""
name = name.strip()
ensure_valid_c_variable_name(name)
self._name = name
self._dimension = dimension
self._valid_range = valid_range # TODO: This is not used currently
def __init__(self, port_name):
"""OutputEvent Constructor
:param port: The name of the output EventPort that should
transmit an event. An `EventPort` with a mode of 'send' must exist
with a corresponding name in the component, otherwise a
``NineMLRuntimeException`` will be raised.
"""
self._port_name = port_name.strip()
ensure_valid_c_variable_name(self._port_name)
def __init__(self, name, dimension=None):
"""Parameter Constructor
:param name: The name of the parameter.
"""
name = name.strip()
ensure_valid_c_variable_name(name)
self._name = name
self._dimension = dimension if dimension is not None else dimensionless
assert isinstance(self._dimension, Dimension), (
"dimension must be None or a nineml.Dimension instance")
def __init__(self, src_port_name, state_assignments=None,
event_outputs=None, target_regime_name=None):
"""Constructor for ``OnEvent``
:param src_port_name: The name of the |EventPort| that triggers this transition
See ``Transition.__init__`` for the definitions of the remaining
parameters.
"""
Transition.__init__(self, state_assignments=state_assignments,
event_outputs=event_outputs,
target_regime_name=target_regime_name)
self._src_port_name = src_port_name.strip()
ensure_valid_c_variable_name(self._src_port_name)
def __init__(self, name, mode='send', reduce_op=None,
dimension='dimensionless'):
""" Port Constructor.
:param name: The name of the port, as a `string`
:param mode: The mode of the port, which should be a string as either,
``send``,``recv`` or ``reduce``.
:param reduce_op: This should be ``None`` unless the mode is
``reduce``. If the mode is ``reduce``, then this must be a
supported ``reduce_op``
.. note::
Currently support ``reduce_op`` s are: ``+``.
"""
name = name.strip()
ensure_valid_c_variable_name(name)
self.dimension = dimension
self._name = name
self._mode = mode
self._reduce_op = reduce_op
if self._mode not in Port._modes:
err = ("%s('%s')" + "specified undefined mode: '%s'") %\
(self.__class__.__name__, self.name, mode)
raise NineMLRuntimeError(err)
if mode == 'reduce':
if reduce_op not in Port._reduce_op_map.keys():
err = ("%s('%s')" + "specified undefined reduce_op: '%s'") %\
(self.__class__.__name__, name, str(reduce_op))
raise NineMLRuntimeError(err)
if reduce_op and mode != "reduce":
err = "Port of mode!=reduce may not specify 'op'."
raise NineMLRuntimeError(err)
def __init__(self, analog_ports=[],
event_ports=[], dynamics=None):
"""Constructor - For parameter descriptions, see the
ComponentClass.__init__() method
"""
self._analog_send_ports = dict((port.name, port)
for port in analog_ports
if isinstance(port, AnalogSendPort))
self._analog_receive_ports = dict((port.name, port)
for port in analog_ports
if isinstance(port,
AnalogReceivePort))
self._analog_reduce_ports = dict((port.name, port)
for port in analog_ports
if isinstance(port, AnalogReducePort))
self._event_send_ports = dict((port.name, port)
for port in event_ports
if isinstance(port, EventSendPort))
self._event_receive_ports = dict((port.name, port)
for port in event_ports
if isinstance(port, EventReceivePort))
self._dynamics = dynamics
ensure_valid_c_variable_name(self.name)
