def __init__(self, name, dimension=None): """StateVariable Constructor :param name: The name of the state variable. """ self._name = name.strip() self._dimension = dimension if dimension is not None else dimensionless ensure_valid_identifier(self._name)
def __init__(self, name): """ Port Constructor. `name` -- The name of the port, as a `string` """ name = name.strip() ensure_valid_identifier(name) self._name = name
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 componentclass, otherwise a ``NineMLRuntimeException`` will be raised. """ self._port_name = port_name.strip() ensure_valid_identifier(self._port_name)
def __init__(self, name, dimension=None): """Parameter Constructor `name` -- The name of the parameter. """ name = name.strip() ensure_valid_identifier(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, name, parameters, main_block): ensure_valid_identifier(name) BaseALObject.__init__(self) self._name = name self._main_block = main_block # Turn any strings in the parameter list into Parameters: if parameters is None: parameters = [] else: param_types = (basestring, Parameter) param_td = filter_discrete_types(parameters, param_types) params_from_strings = [Parameter(s) for s in param_td[basestring]] parameters = param_td[Parameter] + params_from_strings self._parameters = dict((p.name, p) for p in parameters)
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_identifier(self._src_port_name)
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_identifier(self._src_port_name)
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)