fischertechnik-factory-twin/simulator/pythonpdevs/model/model.py

import sys
sys.path.append("../src/")
from DEVS import CoupledDEVS, AtomicDEVS, RootDEVS, directConnect
from infinity import INFINITY
from collections import defaultdict
from util import allZeroDict, addDict

from statesavers import PickleHighestState as state_saver
from message import NetworkMessage
from messageScheduler import MessageScheduler

class SimulatedCModel(CoupledDEVS):
    def __init__(self):
        CoupledDEVS.__init__(self, "root")
        self.model1 = self.addSubModel(SimulatedModel(1), 0)
        self.model2 = self.addSubModel(SimulatedModel(2), 1)
        self.model3 = self.addSubModel(SimulatedModel(3), 1)
        self.connectPorts(self.model1.outport, self.model2.inport)
        self.connectPorts(self.model2.outport, self.model3.inport)
        self.connectPorts(self.model3.outport, self.model1.inport)

class ModelState(object):
    def __init__(self, value):
        self.value = value
        self.stateHistory = []

class SimulatedModel(AtomicDEVS):
    def __init__(self, name):
        AtomicDEVS.__init__(self, str(name))
        self.inport = self.addInPort("inport")
        self.outport = self.addOutPort("outport")
        if name == 1:
            self.state = ModelState(2)
        else:
            self.state = ModelState(None)

    def intTransition(self):
        #print("INTERNAL TRANSITION @ %s, %s" % (self.getModelFullName(), self.timeLast))
        self.state.value = None
        self.state.stateHistory.append("INT " + str(self.timeLast))
        print("HISTORY of %s: %s" % (self.getModelFullName(), self.state.stateHistory))
        return self.state

    def extTransition(self, inputs):
        #print("EXTERNAL TRANSITION @ %s, %s" % (self.getModelFullName(), self.timeLast))
        self.state.value = inputs[self.inport][0]
        self.state.stateHistory.append("EXT " + str(self.timeLast))
        print("HISTORY of %s: %s" % (self.getModelFullName(), self.state.stateHistory))
        return self.state

    def timeAdvance(self):
        if self.state.value is not None:
            return 0.1
        else:
            return 1.0
            #return INFINITY

    def outputFnc(self):
        return {self.outport: [self.state.value]}

class Cluster(CoupledDEVS):
    def __init__(self, nodes):
        CoupledDEVS.__init__(self, "Cluster")
        self.nodes = [self.addSubModel(Node(i, nodes)) for i in range(nodes)]
        self.network = [[self.addSubModel(Network("%i-->%i" % (j, i))) for i in range(nodes)] for j in range(nodes)]

        for startid in range(nodes):
            for endid in range(nodes):
                self.connectPorts(self.nodes[startid].outports[endid], self.network[startid][endid].inport)
                self.connectPorts(self.network[startid][endid].outport, self.nodes[endid].inports[startid])

class NodeState(object):
    def __init__(self, name, totalsize):
        self.simulationtime = (0, 0)
        self.prevtime = (0, 0)
        self.terminationtime = (3, 0)
        model = SimulatedCModel()
        self.model_ids = []
        locations = defaultdict(list)
        model.finalize(name="", model_counter=0, model_ids=self.model_ids, locations=locations, selectHierarchy=[])
        if isinstance(model, CoupledDEVS):
            model.componentSet = directConnect(model.componentSet, True)
        self.destinations = [None] * len(model.componentSet)
        self.kernels = len(locations.keys())
        local = []
        for m in model.componentSet:
            self.destinations[m.model_id] = m if m.location == name else m.location
            if m.location == name:
                m.timeNext = (m.timeAdvance(), 1)
                m.timeLast = (0, 0)
                m.oldStates = [state_saver(m.timeLast, m.timeNext, m.state, 0.0, {}, 0.0)]
                local.append(m)
        self.model = RootDEVS(local, model.componentSet, ("schedulerML", "SchedulerML"))
        self.model.setScheduler(self.model.schedulerType)
        self.model.setTimeNext()
        self.externalQueue = {}
        self.color = False
        self.sendmsgcounter = 0
        self.outputQueue = []
        self.messageScheduler = MessageScheduler()
        self.V = [{}, {}, {}, {}]
        self.Tmin = float('inf')
        self.blockOutgoing = None
        self.run_GVT = 1.0
        self.gvt_check = None
        self.GVT = -float('inf')
        self.relocation_rules = None
        self.kernels_to_relocate = None
        from manualRelocator import ManualRelocator
        self.relocator = ManualRelocator()
        self.relocator.addDirective(1.0, 1, 0)
        self.locked = False
        self.accumulator = {}

    def copy(self):
        #TODO keep this up to date
        import cPickle
        a = cPickle.loads(cPickle.dumps(self))
        a.model = self.model
        a.model_ids = list(self.model_ids)
        a.destinations = list(self.destinations)
        a.externalQueue = dict(self.externalQueue)
        a.outputQueue = list(self.outputQueue)
        return a

    def __getstate__(self):
        retdict = {}
        for i in dir(self):
            if getattr(self, i).__class__.__name__ in ["instancemethod", "method-wrapper", "builtin_function_or_method"]:
                continue
            elif str(i).startswith("__"):
                continue
            retdict[str(i)] = getattr(self, i)
        return retdict

    def __setstate__(self, inp):
        for i in inp:
            setattr(self, i, inp[i])

class Node(AtomicDEVS):
    def __init__(self, name, totalsize):
        AtomicDEVS.__init__(self, "Node_%i" % name)
        self.nodename = name
        self.totalsize = totalsize
        self.inports = [self.addInPort("inport_%i" % i) for i in range(totalsize)]
        self.outports = [self.addOutPort("outport_%i" % i) for i in range(totalsize)]
        self.state = NodeState(name, totalsize)

    def genUUID(self):
        self.state.sendmsgcounter += 1
        return "%s-%s" % (self.nodename, self.state.sendmsgcounter)

    def send(self, model_id, timestamp, content):
        if self.state.blockOutgoing == timestamp:
            return
        msg = NetworkMessage(timestamp, content, self.genUUID(), self.state.color, model_id)
        self.state.outputQueue.append(msg)
        self.notifySend(self.state.destinations[model_id], timestamp[0], msg.color)
        self.state.externalQueue.setdefault(self.outports[self.state.destinations[model_id]], []).append(msg)

    def processMessage(self, clock):
        try:
            message = self.state.messageScheduler.readFirst()
        except IndexError:
            # No input messages
            return clock
        if message.timestamp < clock:
            # The message is sent before the timenext, so update the clock
            clock = message.timestamp
        try:
            while (abs(clock[0] - message.timestamp[0]) < 1e-6 and (clock[1] == message.timestamp[1])):
                print("Process message with UUID " + str(message.uuid))
                for port in message.content:
                    port.hostDEVS.myInput.setdefault(port, []).extend(message.content[port])
                    self.state.transitioning[port.hostDEVS] |= 2
                self.state.messageScheduler.removeFirst()
                message = self.state.messageScheduler.readFirst()
        except IndexError:
            # At the end of the scheduler, so we are done
            pass
        return clock

    def receiveControl(self, msg, first=False):
        self.state.controlmsg = msg
        m_clock = msg[0]
        m_send = msg[1]
        waiting_vector = msg[2]
        accumulating_vector = msg[3]

        color = self.state.color
        finished = (self.nodename == 0 and not first and (color == 0 or color == 2))
        if self.nodename == 0 and not first:
            if not allZeroDict(waiting_vector):
                raise DEVSException("GVT bug detected")
            waiting_vector = accumulating_vector
            accumulating_vector = {}
        if finished:
            from math import floor
            GVT = floor(min(m_clock, m_send))
            self.state.accumulator = waiting_vector
            self.state.externalQueue.setdefault(self.outports[self.nodename], []).append(("setGVT_local", [GVT, [], self.state.relocator.useLastStateOnly()]))
            return None
        else:
            return self.tryIfOk(color, waiting_vector, accumulating_vector)

        """
        if self.state.color == 0 or self.state.color == 2:
            # We are currently white, about to turn red
            if self.nodename == 0 and not first:
                # The controller received the message that went around completely
                # The count != check is needed to distinguish between init and finish
                # So we are finished now, don't update the color here!!
                if not allZeroDict(count):
                    raise DEVSException("GVT bug detected")
                # Perform some rounding to prevent slight deviations due to floating point errors
                from math import floor
                GVT = floor(min(m_clock, m_send))
                print("Found GVT " + str(GVT))
                # Do this with a proxy to make it async
                self.state.externalQueue.setdefault(self.outports[self.nodename], []).append(("setGVT_local", [GVT, [], self.state.relocator.useLastStateOnly()]))
            else:
                # Either at the controller at init
                #  or just a normal node that is about to turn red
                self.state.color = (self.state.color + 1) % 4
                addDict(count, self.state.V[v])
                self.state.V[v] = {}
                msg = [min(m_clock, self.state.prevtime[0]), min(m_send, self.state.Tmin), count]
                self.state.externalQueue.setdefault(self.outports[(self.nodename+1)%self.totalsize], []).append(("receiveControl", [msg]))
            return None
        elif self.state.color == 1 or self.state.color == 3:
            # We are currently red, about to turn white
            # First wait for all messages in the medium
            return self.tryIfOk(v, count)
        """

    def findAndPerformRelocations(self, GVT, activities, horizon):
        relocate = self.state.relocator.getRelocations(GVT, activities, horizon)
        relocate = {key: relocate[key] for key in relocate if self.state.model_ids[key].location != relocate[key] and self.state.model_ids[key].relocatable}

        if not relocate:
            self.state.run_GVT = 1.0
            return

        kernels = {}
        self.state.locked_kernels = set()
        relocation_rules = {}
        for model_id in relocate:
            source = self.state.model_ids[model_id].location
            destination = relocate[model_id]
            if source == destination:
                continue
            kernels[source] = kernels.get(source, 0) + 1
            kernels[destination] = kernels.get(destination, 0) + 1
            if kernels[source] == 1:
                # We are the first to lock it, so actually send the lock
                self.state.externalQueue.setdefault(self.outports[source], []).append(("requestMigrationLock", []))
                #self.getProxy(source).requestMigrationLock()
            if kernels[destination] == 1:
                # We are the first to lock it, so actually send the lock
                self.state.externalQueue.setdefault(self.outports[destination], []).append(("requestMigrationLock", []))
                #self.getProxy(destination).requestMigrationLock()
            relocation_rules.setdefault((source, destination), set()).add(model_id)
        self.performRelocations(relocation_rules, kernels)

    def performRelocations(self, relocation_rules, kernels):
            for source, destination in relocation_rules.keys():
                if source in self.state.locked_kernels and destination in self.state.locked_kernels:
                    models = relocation_rules[(source, destination)]
                    unlock = []
                    if kernels[source] == 1:
                        unlock.append(source)
                    if kernels[destination] == 1:
                        unlock.append(destination)
                    self.state.externalQueue.setdefault(self.outports[source], []).append(("migrateTo", [destination, models, unlock]))
                    #self.getProxy(source).migrateTo(destination, models)
                    del relocation_rules[(source, destination)]
                    kernels[source] -= len(models)
                    kernels[destination] -= len(models)
            if relocation_rules:
                # Still something to do
                self.state.relocation_rules = relocation_rules
                self.state.kernels_to_relocate = kernels
            else:
                # At the end, so a normal return
                self.state.relocation_rules = None
                self.state.kernels_to_relocate = None

    def setGVT_local(self, GVT, activities, lastStateOnly):
        if GVT < self.state.GVT:
            raise DEVSException("GVT cannot decrease from " + str(self.GVT) + " to " + str(GVT) + "!")
        if GVT == self.state.GVT:
            # At the controller too
            # Restart the GVT algorithm within 1 time unit
            if activities:
                if self.state.oldGVT == -float('inf'):
                    self.oldGVT = 0.
                horizon = self.state.GVT - self.state.oldGVT
                self.findAndPerformRelocations(GVT, activities, horizon)
        else:
            self.state.oldGVT = self.state.GVT
            self.state.GVT = GVT

            nqueue = []
            self.state.messageScheduler.cleanup((GVT, 1))

            #self.performActions(GVT)

            found = False
            for index in range(len(self.state.outputQueue)):
                if self.state.outputQueue[index].timestamp[0] >= GVT:
                    found = True
                    self.state.outputQueue = self.state.outputQueue[index:]
                    break
            if not found:
                self.state.outputQueue = []
            self.state.activities = {}
            self.state.model.setGVT(GVT, self.state.activities, lastStateOnly)
            if lastStateOnly:
                activitySum = 0
            else:
                activitySum = sum(self.state.activities.values())
            activities.append((self.name, activitySum))
            self.state.externalQueue.setdefault(self.outports[(self.nodename+1)%self.totalsize], []).append(("setGVT_local", [GVT, activities, lastStateOnly]))

    def tryIfOk(self, color, waiting_vector, accumulating_vector):
        prevcolor = 3 if color == 0 else color - 1
        if self.state.V[prevcolor].get(self.nodename, 0) + self.state.controlmsg[2].get(self.nodename, 0) <= 0:
            addDict(waiting_vector, self.state.V[prevcolor])
            addDict(accumulating_vector, self.state.V[color])
            self.state.V[prevcolor] = {}
            self.state.V[color] = {}
            ntime = self.state.prevtime[0] if self.nodename == 0 else min(self.state.controlmsg[0], self.state.prevtime[0])
            msg = [ntime, min(self.state.controlmsg[1], self.state.Tmin), waiting_vector, accumulating_vector]
            self.state.Tmin = float('inf')
            self.state.externalQueue.setdefault(self.outports[(self.nodename+1)%self.totalsize], []).append(("receiveControl", [msg]))
            self.state.color = (self.state.color + 1) % 4
            return False
        else:
            return color, waiting_vector, accumulating_vector
        
    def activateModel(self, model_id, currentState):
        new_model = self.state.model_ids[model_id]
        old_location = new_model.location
        new_model.location = self.nodename
        self.state.model.componentSet.append(new_model)
        self.state.model.local_model_ids.add(new_model.model_id)
        new_model.timeLast = currentState[0]
        new_model.timeNext = currentState[1]
        new_model.state = currentState[2]
        new_model.oldStates = [state_saver(new_model.timeLast, new_model.timeNext, new_model.state, 0.0, {}, 0.0)]
        # It is a new model, so add it to the scheduler too
        self.state.model.scheduler.schedule(new_model)
        self.state.destinations[model_id] = new_model
        self.state.model.setTimeNext()
        self.state.activities[model_id] = 0.0

    def messageTransfer(self, extraction):
        self.state.messageScheduler.insert(extraction, self.state.model_ids)

    def migrateTo(self, destination, model_ids, unlock):
        # Assumes that the simlock is already acquired
        # Make sure that the model that we are migrating is local here
        #assert info("Migrating " + str(model_ids) + " to " + str(destination))
        models = set()
        for model_id in model_ids:
            if isinstance(self.state.destinations[model_id], int):
                raise DEVSException("Cannot migrate model that is not local to the source!")
            if not self.state.destinations[model_id].relocatable:
                raise DEVSException("Model %s was marked as fixed and is therefore not allowed to be relocated" % self.state.destinations[model_id].getModelFullName())
            models.add(self.state.destinations[model_id])
        destination = int(destination)
        if destination == self.name:
            # Model is already there...
            return
        #assert info("Migration approved of %s from node %d to node %d" % (model_ids, self.name, destination))

        for model in models:
            # All models are gone here, so remove them from the scheduler
            self.state.model.scheduler.unschedule(model)

        for i in range(self.state.kernels):
            if i != destination and i != self.name:
                self.state.externalQueue.setdefault(self.outports[i], []).append(("notifyMigration", [model_ids, destination]))
                #self.getProxy(i).notifyMigration(model_ids, destination)
        self.state.externalQueue.setdefault(self.outports[destination], []).append(("messageTransfer", [self.state.messageScheduler.extract(model_ids)]))
        #remote.messageTransfer(self.inputScheduler.extract(model_ids))
        for model in models:
            # No need to ask the new node whether or not there are specific nodes that also have to be informed
            self.state.externalQueue.setdefault(self.outports[destination], []).append(("activateModel", [model.model_id, (model.timeLast, model.timeNext, model.state)]))
            #remote.activateModel(model.model_id, (model.timeLast, model.timeNext, model.state))
            # Delete our representation of the model
            model.state = None
            model.oldStates = []
            del self.state.activities[model.model_id]
        for m in unlock:
            self.state.externalQueue.setdefault(self.outports[m], []).append(("migrationUnlock", []))

        # Remove the model from the componentSet of the RootDEVS
        self.state.model.componentSet = [m for m in self.state.model.componentSet if m not in models]
        for model_id in model_ids:
            self.state.model.local_model_ids.remove(model_id)
            self.state.destinations[model_id] = destination
            self.state.model_ids[model_id].location = destination

        # Now update the timeNext and timeLast values here
        self.state.model.setTimeNext()

    def notifyMigration(self, model_ids, destination):
        if destination == self.nodename:
            # No need to notify ourselves, simply here for safety as it shouldn't be called
            return
        for model_id in model_ids:
            self.state.destinations[model_id] = destination
            self.state.model_ids[model_id].location = destination

    def requestMigrationLock(self):
        self.state.locked = True
        self.revert_local((self.state.GVT, 0))
        self.state.externalQueue.setdefault(self.outports[0], []).append(("notifyLocked", [self.nodename]))

    def migrationUnlock(self):
        self.state.locked = False

    def notifyLocked(self, name):
        self.state.locked_kernels.add(name)

    def intTransition(self):
        # Just do some processing
        self.state.run_GVT -= self.timeAdvance()
        self.state.externalQueue = {}
        self.state.transitioning = defaultdict(int)

        if self.state.run_GVT <= 0 and self.nodename == 0:
            # Start the GVT algorithm
            self.receiveControl([float('inf'), float('inf'), self.state.accumulator, {}], True)
            self.state.run_GVT = float('inf')
        if self.state.gvt_check is not None:
            rv = self.tryIfOk(*self.state.gvt_check)
            if not isinstance(rv, tuple):
                self.state.gvt_check = None

        if self.state.relocation_rules is not None:
            self.performRelocations(self.state.relocation_rules, self.state.kernels_to_relocate)
            return self.state

        if self.state.locked:
            return self.state

        ctime = self.processMessage(self.state.model.timeNext)
        if ctime > self.state.terminationtime:
            self.state.simulationtime = ctime
            return self.state
        outputs = {}
        transitioning = self.state.model.scheduler.getImminent(ctime)
        for i in transitioning:
            outputs.update(i.outputFnc())
            self.state.transitioning[i] |= 1
        remotes = {}
        for i in outputs:
            for dest in i.outLine:
                destADEVS = dest.hostDEVS
                if destADEVS.location == self.nodename:
                    destADEVS.myInput.setdefault(dest, []).extend(outputs[i])
                    self.state.transitioning[destADEVS] |= 2
                else:
                    remotes.setdefault(destADEVS.model_id, {}).setdefault(dest.port_id, []).extend(outputs[i])
        for destination in remotes:
            self.send(destination, ctime, remotes[destination])
        for aDEVS in self.state.transitioning:
            t = self.state.transitioning[aDEVS]
            aDEVS.timeLast = ctime
            activityTrackingPreValue = aDEVS.preActivityCalculation()
            if t == 1:
                aDEVS.state = aDEVS.intTransition()
            elif t == 2:
                aDEVS.elapsed = ctime[0] - aDEVS.timeLast[0] 
                aDEVS.state = aDEVS.extTransition(aDEVS.myInput)
            elif t == 3:
                aDEVS.state = aDEVS.confTransition(aDEVS.myInput)
            ta = aDEVS.timeAdvance()
            aDEVS.timeNext = (aDEVS.timeLast[0] + ta, 1 if ta != 0 else aDEVS.timeLast[1] + 1)
            aDEVS.oldStates.append(state_saver(aDEVS.timeLast, aDEVS.timeNext, aDEVS.state, aDEVS.postActivityCalculation(activityTrackingPreValue), {}, 0))
            aDEVS.myInput = {}
        self.state.model.scheduler.massReschedule(self.state.transitioning.keys())
        self.state.prevtime = ctime
        self.state.model.setTimeNext()
        self.state.simulationtime = self.state.model.timeNext
        return self.state

    def notifyReceive(self, color):
        self.state.V[color][self.nodename] = self.state.V[color].get(self.nodename, 0) - 1

    def notifySend(self, destination, timestamp, color):
         self.state.V[color][destination] = self.state.V[color].get(destination, 0) + 1
         if color == 1 or color == 3:
            self.state.Tmin = min(self.state.Tmin, timestamp)

    def revert_local(self, time):
        self.state.messageScheduler.revert(time)
        self.state.model.revert(time, False)
        self.state.model.setTimeNext()
        self.state.prevtime = time
        self.state.simulationtime = (0, 0)

        # Invalidate all output messages after or at time
        end = -1
        unschedules = {}
        unschedules_mintime = {}
        print("Reverting to time " + str(time))
        for index, value in enumerate(self.state.outputQueue):
            # Do not invalidate messages at this time itself, as they are processed in this time step and not generated in this timestep
            if value.timestamp > time:
                model_id = value.destination
                unschedules_mintime[model_id] = min(unschedules_mintime.get(model_id, (float('inf'), 0)), value.timestamp)
                unschedules.setdefault(model_id, []).append(value.uuid)
            else:
                #assert debug("NOT invalidating " + str(value.uuid))
                end = index
        self.state.outputQueue = self.state.outputQueue[:end+1]

        try:
            self.state.blockOutgoing = self.state.outputQueue[-1].timestamp
        except IndexError:
            self.state.blockOutgoing = None

        # Don't need the Vlock here, as we already have it
        for model_id in unschedules:
            dest_kernel = self.state.destinations[model_id]
            if not isinstance(dest_kernel, int):
                raise DEVSException("Impossible")
                continue
            mintime = unschedules_mintime[model_id]
            # Assume we have the simlock already
            self.state.externalQueue.setdefault(self.outports[dest_kernel], []).append(("receiveAntiMessage", [mintime, model_id, unschedules[model_id], self.state.color]))
            self.notifySend(dest_kernel, mintime[0], self.state.color)

    def extTransition(self, inputs):
        self.state.run_GVT -= self.elapsed
        for port in inputs:
            for msg in inputs[port]:
                if isinstance(msg, NetworkMessage):
                    self.notifyReceive(msg.color)
                    if msg.destination not in self.state.model.local_model_ids:
                        print("FORWARD MSG " + str(msg.uuid))
                        dest = self.state.destinations[msg.destination]
                        msg.color = self.state.color
                        self.notifySend(dest, msg.timestamp[0], msg.color)
                        self.state.externalQueue.setdefault(self.outports[dest], []).append(msg)
                        continue
                    msg.content = {self.state.model_ids[msg.destination].ports[port]: msg.content[port] for port in msg.content}
                    if msg.timestamp <= self.state.prevtime:
                        self.revert_local(msg.timestamp)
                    self.state.messageScheduler.schedule(msg)
                elif isinstance(msg, tuple):
                    # Other kind of message
                    action, args = msg
                    if action == "receiveControl":
                        rv = getattr(self, action)(*args)
                        if isinstance(rv, tuple):
                            # Try again later
                            self.state.gvt_check = rv
                        else:
                            self.state.gvt_check = None
                    else:
                        getattr(self, action)(*args)
        # Put the return values in a queue if necessary
        self.state.simulationtime = (0, 0)
        return self.state

    def receiveAntiMessage(self, time, model_id, uuids, color):
        self.notifyReceive(color)
        print("Received anti message for uuids " + str(uuids))
        if model_id not in self.state.model.local_model_ids and model_id is not None:
            print("FORWARD ANTIMSG")
            self.state.externalQueue.setdefault(self.outports[self.state.destinations[model_id]], []).append(("receiveAntiMessages", [mintime, model_id, uuids, self.state.color]))
            self.notifySend(self.state.destinations[model_id], mintime[0], self.state.color)
            return
        if time <= self.state.prevtime:
            self.revert_local(time)
        self.state.messageScheduler.massUnschedule(uuids)

    def timeAdvance(self):
        if self.state.externalQueue:
            return 0.01
        elif self.state.simulationtime < self.state.terminationtime:
            return 0.1
        else:
            return INFINITY

    def outputFnc(self):
        return self.state.externalQueue

class NetworkState(object):
    def __init__(self):
        self.lst = []

    def copy(self):
        a = NetworkState()
        a.lst = list(self.lst)
        return a

class Network(AtomicDEVS):
    def __init__(self, name):
        AtomicDEVS.__init__(self, name)
        self.state = NetworkState()
        self.inport = self.addInPort("inport")
        self.outport = self.addOutPort("outport")

    def intTransition(self):
        self.state.lst = []
        return self.state

    def extTransition(self, inputs):
        msgs = inputs[self.inport]
        self.state.lst.extend(msgs)
        return self.state

    def timeAdvance(self):
        if self.state.lst:
            #return 1.0
            return 0.1
            #return 0.01
        else:
            return INFINITY

    def outputFnc(self):
        return {self.outport: self.state.lst}