Initial commit

2016-08-04 17:38:43 +02:00 · 2016-08-04 17:38:43 +02:00 · 66a6860316
commit 66a6860316
407 changed files with 1254365 additions and 0 deletions
--- a/test/testmodels/models.py
+++ b/test/testmodels/models.py
@ -0,0 +1,939 @@
+import sys
+import os.path
+
+from pypdevs.infinity import *
+from pypdevs.DEVS import AtomicDEVS, CoupledDEVS
+
+class Event(object):
+    def __init__(self, eventSize):
+        self.eventSize = eventSize
+
+    def __str__(self):
+        return "Eventsize = " + str(self.eventSize)
+
+class ModelState(object):
+    def __init__(self):
+        self.counter = INFINITY
+        self.event = None
+
+    def __str__(self):
+        return str(self.counter)
+
+    def toXML(self):
+        return "<counter>" + str(self.counter) + "</counter>"
+
+class ProcessorNPP(AtomicDEVS):
+    def __init__(self, name = "Processor", t_event1 = 1):
+        AtomicDEVS.__init__(self, name)
+        self.t_event1 = t_event1
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.state = ModelState()
+        
+    def timeAdvance(self):
+        return self.state.counter
+
+    def intTransition(self):
+        self.state.counter -= self.timeAdvance()
+        if self.state.counter == 0:
+            self.state.counter = INFINITY
+            self.state.event = None
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.counter -= self.elapsed
+        ev1 = inputs[self.inport][0]
+        if ev1 != None:
+            self.state.event = ev1
+            self.state.counter = self.t_event1
+        return self.state
+
+    def outputFnc(self):
+        output = {}
+        mini = self.state.counter
+        if self.state.counter == mini:
+            output[self.outport] = [self.state.event]
+        return output
+
+class RemoteDCProcessor(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "RemoteDCProcessor")
+        mod = self.addSubModel(CoupledProcessor(1, 1), 2)
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.connectPorts(self.inport, mod.inport)
+        self.connectPorts(mod.outport, self.outport)
+
+class Processor(AtomicDEVS):
+    def __init__(self, name = "Processor", t_event1 = 1):
+        AtomicDEVS.__init__(self, name)
+        self.t_event1 = t_event1
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.state = ModelState()
+        
+    def timeAdvance(self):
+        return self.state.counter
+
+    def intTransition(self):
+        self.state.counter -= self.timeAdvance()
+        if self.state.counter == 0:
+            self.state.counter = INFINITY
+            self.state.event = None
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.counter -= self.elapsed
+        ev1 = inputs[self.inport][0]
+        if ev1 != None:
+            self.state.event = ev1
+            self.state.counter = self.t_event1
+        return self.state
+
+    def outputFnc(self):
+        mini = self.state.counter
+        if self.state.counter == mini:
+            return {self.outport: [self.state.event]}
+        else:
+            return {}
+
+class HeavyProcessor(AtomicDEVS):
+    def __init__(self, name = "Processor", t_event1 = 1, iterations = 0):
+        AtomicDEVS.__init__(self, name)
+        self.t_event1 = t_event1
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.state = ModelState()
+        self.iterations = iterations
+        
+    def timeAdvance(self):
+        return self.state.counter
+
+    def intTransition(self):
+        self.state.counter -= self.timeAdvance()
+        # Do lots of work now
+        stupidcounter = 0
+        for _ in xrange(self.iterations):
+            pass
+        if self.state.counter == 0:
+            self.state.counter = INFINITY
+            self.state.event = None
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.counter -= self.elapsed
+        ev1 = inputs[self.inport][0]
+        stupidcounter = 0
+        for _ in xrange(self.iterations):
+            pass
+        if ev1 != None:
+            self.state.event = ev1
+            self.state.counter = self.t_event1
+        return self.state
+
+    def outputFnc(self):
+        mini = self.state.counter
+        stupidcounter = 0
+        for _ in xrange(self.iterations):
+            pass
+        if self.state.counter == mini:
+            return {self.outport: [self.state.event]}
+
+class NestedProcessor(Processor):
+    def __init__(self, name = "NestedProcessor"):
+        Processor.__init__(self, name)
+        self.state.processed = 0
+        self.state.event = Event(5)
+
+    def extTransition(self, inputs):
+        self.state = Processor.extTransition(self, inputs)
+        self.state.processed += 1
+        return self.state
+
+    def timeAdvance(self):
+        from pypdevs.simulator import Simulator
+        model = CoupledGenerator()
+        sim = Simulator(model)
+        sim.setTerminationTime(self.state.processed)
+        #sim.setVerbose(True)
+        sim.simulate()
+        result = max(sim.model.generator.state.generated, 1)
+        return result
+
+class Generator(AtomicDEVS):
+    def __init__(self, name = "Generator", t_gen_event1 = 1.0, binary = False):
+        AtomicDEVS.__init__(self, name)
+        self.state = ModelState()
+        # Add an extra variable
+        self.state.generated = 0
+        self.state.counter = t_gen_event1
+        self.state.value = 1
+        self.t_gen_event1 = t_gen_event1
+        self.outport = self.addOutPort("outport")
+        self.inport = self.addInPort("inport")
+        self.binary = binary
+        
+    def timeAdvance(self):
+        return self.state.counter
+
+    def intTransition(self):
+        self.state.generated += 1
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.counter -= self.elapsed
+        return self.state
+
+    def outputFnc(self):
+        if self.binary:
+            return {self.outport: ["b1"]}
+        else:
+            return {self.outport: [Event(self.state.value)]}
+
+class GeneratorNPP(AtomicDEVS):
+    def __init__(self, name = "Generator", t_gen_event1 = 1.0):
+        AtomicDEVS.__init__(self, name)
+        self.state = ModelState()
+        # Add an extra variable
+        self.state.generated = 0
+        self.state.counter = t_gen_event1
+        self.t_gen_event1 = t_gen_event1
+        self.outport = self.addOutPort("outport")
+        self.inport = self.addInPort("inport")
+        
+    def timeAdvance(self):
+        return self.state.counter
+
+    def intTransition(self):
+        self.state.generated += 1
+        return self.state
+
+    def extTransition(self, inputs):
+        self.state.counter -= self.elapsed
+        return self.state
+
+    def outputFnc(self):
+        return {self.outport: [Event(1)]}
+
+class CoupledGenerator(CoupledDEVS):
+    def __init__(self, t_gen_event1 = 1, binary = False):
+        CoupledDEVS.__init__(self, "CoupledGenerator")
+        self.generator = self.addSubModel(Generator("Generator", t_gen_event1, binary))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.connectPorts(self.inport, self.generator.inport)
+        self.connectPorts(self.generator.outport, self.outport)
+
+class CoupledGeneratorNPP(CoupledDEVS):
+    def __init__(self, t_gen_event1 = 1):
+        CoupledDEVS.__init__(self, "CoupledGenerator")
+        self.generator = self.addSubModel(GeneratorNPP("Generator", t_gen_event1))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.connectPorts(self.inport, self.generator.inport)
+        self.connectPorts(self.generator.outport, self.outport)
+
+class CoupledHeavyProcessor(CoupledDEVS):
+    def __init__(self, t_event1_P1, levels, iterations, name = None):
+        if name == None:
+            name = "CoupledHeavyProcessor_" + str(levels)
+        CoupledDEVS.__init__(self, name)
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.coupled = []
+        for i in range(levels):
+            self.coupled.append(self.addSubModel(HeavyProcessor("Processor" + str(i), t_event1_P1, iterations)))
+        for i in range(levels-1):
+            self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport)
+        self.connectPorts(self.inport, self.coupled[0].inport)
+        self.connectPorts(self.coupled[-1].outport, self.outport)
+
+class CoupledProcessorNPP(CoupledDEVS):
+    def __init__(self, t_event1_P1, levels):
+        CoupledDEVS.__init__(self, "CoupledProcessor_" + str(levels))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.coupled = []
+        for i in range(levels):
+            self.coupled.append(self.addSubModel(ProcessorNPP("Processor" + str(i), t_event1_P1)))
+        for i in range(levels-1):
+            self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport)
+        self.connectPorts(self.inport, self.coupled[0].inport)
+        self.connectPorts(self.coupled[-1].outport, self.outport)
+
+class CoupledProcessor(CoupledDEVS):
+    def __init__(self, t_event1_P1, levels):
+        CoupledDEVS.__init__(self, "CoupledProcessor_" + str(levels))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.coupled = []
+        for i in range(levels):
+            self.coupled.append(self.addSubModel(Processor("Processor" + str(i), t_event1_P1)))
+        for i in range(levels-1):
+            self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport)
+        self.connectPorts(self.inport, self.coupled[0].inport)
+        self.connectPorts(self.coupled[-1].outport, self.outport)
+
+class CoupledProcessorMP(CoupledDEVS):
+    def __init__(self, t_event1_P1):
+        CoupledDEVS.__init__(self, "CoupledProcessorMP")
+        self.inport = self.addInPort("inport")
+
+        p1 = self.addSubModel(Processor("Processor1", t_event1_P1))
+        p2 = self.addSubModel(Processor("Processor2", t_event1_P1))
+        p3 = self.addSubModel(Processor("Processor3", t_event1_P1))
+        p4 = self.addSubModel(Processor("Processor4", t_event1_P1))
+        self.connectPorts(self.inport, p1.inport)
+        self.connectPorts(self.inport, p3.inport)
+        self.connectPorts(p1.outport, p2.inport)
+        self.connectPorts(p3.outport, p4.inport)
+
+class Binary(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Binary")
+        self.generator = self.addSubModel(CoupledGenerator(1.0, True))
+        self.processor1 = self.addSubModel(CoupledProcessor(0.6, 2), 2)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3), 1)
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class Binary_local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Binary")
+        self.generator = self.addSubModel(CoupledGenerator(1.0, True))
+        self.processor1 = self.addSubModel(CoupledProcessor(0.6, 2))
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class Chain_local(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "Chain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 2))
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class Chain(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "Chain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 2), 2)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class Boundary(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Boundary")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
+        self.processor1 = self.addSubModel(CoupledProcessor(0.60, 2), 2)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 4), 3)
+        self.processor3 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor1.outport, self.processor3.inport)
+        self.connectPorts(self.processor2.outport, self.processor3.inport)
+
+class Two(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Two")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
+        self.processor1 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+
+class DualChain_local(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 2))
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.generator.outport, self.processor2.inport)
+
+class DualChain(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 2), 2)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.generator.outport, self.processor2.inport)
+
+class DualChainMP_local(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualChainMP")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessorMP(0.66))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+
+class DualChainMP(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualChainMP")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 1)
+        self.processor1 = self.addSubModel(CoupledProcessorMP(0.66), 2)
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+
+class DualDepthProcessor_local(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualDepthProcessor")
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 1))
+        self.processor2 = self.addSubModel(CoupledProcessor(ta, 2))
+        self.connectPorts(self.inport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor2.outport, self.outport)
+
+class DualDepthProcessor(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualDepthProcessor")
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.processor1 = self.addSubModel(CoupledProcessor(ta, 1), 2)
+        self.processor2 = self.addSubModel(CoupledProcessor(ta, 2))
+        self.connectPorts(self.inport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor2.outport, self.outport)
+
+class DualDepth_local(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualDepth")
+        self.generator = self.addSubModel(Generator("Generator", 1.0))
+        self.processor = self.addSubModel(DualDepthProcessor_local(ta))
+        self.connectPorts(self.generator.outport, self.processor.inport)
+
+class DualDepth(CoupledDEVS):
+    def __init__(self, ta):
+        CoupledDEVS.__init__(self, "DualDepth")
+        self.generator = self.addSubModel(Generator("Generator", 1.0))
+        self.processor = self.addSubModel(DualDepthProcessor(ta), 1)
+        self.connectPorts(self.generator.outport, self.processor.inport)
+
+class Nested_local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Nested")
+        self.generator = self.addSubModel(Generator("Generator", 1))
+        self.processor = self.addSubModel(NestedProcessor("NProcessor"))
+        self.connectPorts(self.generator.outport, self.processor.inport)
+
+class MultiNested(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "MultiNested")
+        self.generator = self.addSubModel(Generator("Generator", 1))
+        self.processor1 = self.addSubModel(NestedProcessor("NProcessor1"), 1)
+        self.processor2 = self.addSubModel(NestedProcessor("NProcessor2"), 2)
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class Local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Local")
+        self.generator = self.addSubModel(Generator("Generator", 1))
+        self.processor1 = self.addSubModel(CoupledProcessor(1, 2))
+        self.processor2 = self.addSubModel(CoupledProcessor(1, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class OptimizableChain(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "OptimizableChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3), 2)
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class HugeOptimizableChain(CoupledDEVS):
+    def __init__(self, iterations):
+        CoupledDEVS.__init__(self, "HugeOptimizableChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor0 = self.addSubModel(CoupledHeavyProcessor(0.77, 10, iterations))
+        self.processor1 = self.addSubModel(CoupledHeavyProcessor(0.66, 10, iterations), 1)
+        self.processor2 = self.addSubModel(CoupledHeavyProcessor(0.30, 10, iterations), 2)
+        self.connectPorts(self.generator.outport, self.processor0.inport)
+        self.connectPorts(self.processor0.outport, self.processor1.inport)
+        self.connectPorts(self.processor0.outport, self.processor2.inport)
+
+class HugeOptimizableLocalChain(CoupledDEVS):
+    def __init__(self, iterations):
+        CoupledDEVS.__init__(self, "HugeOptimizableChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor0 = self.addSubModel(CoupledHeavyProcessor(0.77, 10, iterations))
+        self.processor1 = self.addSubModel(CoupledHeavyProcessor(0.66, 10, iterations))
+        self.processor2 = self.addSubModel(CoupledHeavyProcessor(0.30, 10, iterations))
+        self.connectPorts(self.generator.outport, self.processor0.inport)
+        self.connectPorts(self.processor0.outport, self.processor1.inport)
+        self.connectPorts(self.processor0.outport, self.processor2.inport)
+
+class LocalLong(CoupledDEVS):
+    def __init__(self, name):
+        CoupledDEVS.__init__(self, name)
+        self.generator = self.addSubModel(Generator("Generator", 1))
+        self.processor1 = self.addSubModel(CoupledProcessor(0.66, 20))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+
+class ParallelChain(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ParallelChain")
+        self.processor1 = self.addSubModel(LocalLong('Local1'), 1)
+        self.processor2 = self.addSubModel(LocalLong('Local2'), 2)
+
+class ParallelLocalChain(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ParallelLocalChain")
+        self.processor1 = self.addSubModel(LocalLong('Local1'))
+        self.processor2 = self.addSubModel(LocalLong('Local2'))
+
+class ChainNoPeekPoke(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ChainNoPeekPoke")
+        self.generator = self.addSubModel(CoupledGeneratorNPP(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessorNPP(0.66, 2))
+        self.processor2 = self.addSubModel(CoupledProcessorNPP(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class ChainPeekPoke(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ChainPeekPoke")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2))
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class AutoDistChain(CoupledDEVS):
+    def __init__(self, nodes, totalAtomics, iterations):
+        CoupledDEVS.__init__(self, "AutoDistChain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processors = []
+        have = 0
+        ta = 0.66
+        for i in range(nodes):
+            shouldhave = (float(i+1) / nodes) * totalAtomics
+            num = int(shouldhave - have)
+            have += num
+            if i == 0:
+                self.processors.append(self.addSubModel(CoupledHeavyProcessor(ta, num, iterations, "HeavyProcessor_" + str(i))))
+            else:
+                self.processors.append(self.addSubModel(CoupledHeavyProcessor(ta, num, iterations, "HeavyProcessor_" + str(i)), i))
+        self.connectPorts(self.generator.outport, self.processors[0].inport)
+        for i in range(len(self.processors)-1):
+            self.connectPorts(self.processors[i].outport, self.processors[i+1].inport)
+
+class RemoteDC(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Root")
+        self.generator = self.addSubModel(CoupledGenerator(1.0))
+        self.processor1 = self.addSubModel(RemoteDCProcessor(), 1)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.30, 3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+
+class MultipleInputs(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "MultipleInputs")
+        self.generator = self.addSubModel(Generator(1.0))
+        self.processors1 = []
+        for i in xrange(5):
+            self.processors1.append(self.addSubModel(Processor("1-" + str(i), 0.3), 1))
+            self.connectPorts(self.generator.outport, self.processors1[-1].inport)
+        self.processors2 = []
+        for i in xrange(2):
+            self.processors2.append(self.addSubModel(Processor("2-" + str(i), 0.3), 2))
+            for s in self.processors1:
+                self.connectPorts(s.outport, self.processors2[-1].inport)
+
+class MultipleInputs_local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "MultipleInputs")
+        self.generator = self.addSubModel(Generator(1.0))
+        self.processors1 = []
+        for i in xrange(5):
+            self.processors1.append(self.addSubModel(Processor("1-" + str(i), 0.3)))
+            self.connectPorts(self.generator.outport, self.processors1[-1].inport)
+        self.processors2 = []
+        for i in xrange(2):
+            self.processors2.append(self.addSubModel(Processor("2-" + str(i), 0.3)))
+            for s in self.processors1:
+                self.connectPorts(s.outport, self.processors2[-1].inport)
+
+class DoubleLayer1(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Layer1")
+        self.inport = self.addInPort("inport")
+        self.processor = self.addSubModel(Processor("Processor", 0.3))
+        self.connectPorts(self.inport, self.processor.inport)
+
+class DoubleLayer2(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Layer2")
+        self.lower = self.addSubModel(DoubleLayer1())
+        self.inport1 = self.addInPort("inport1")
+        self.inport2 = self.addInPort("inport2")
+        self.connectPorts(self.inport1, self.lower.inport)
+        self.connectPorts(self.inport2, self.lower.inport)
+
+class DoubleLayerRoot(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Root")
+        self.lower = self.addSubModel(DoubleLayer2())
+        self.generator = self.addSubModel(Generator("Generator", 1))
+        self.connectPorts(self.generator.outport, self.lower.inport1)
+        self.connectPorts(self.generator.outport, self.lower.inport2)
+
+class DSDEVSRoot(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Root")
+        self.submodel = self.addSubModel(GeneratorDS())
+        self.submodel2 = self.addSubModel(Processor())
+        self.submodel3 = self.addSubModel(Processor())
+        self.connectPorts(self.submodel.outport, self.submodel2.inport)
+        self.connectPorts(self.submodel2.outport, self.submodel3.inport)
+        self.connectPorts(self.submodel.outport, self.submodel3.inport)
+
+    def modelTransition(self, state):
+        self.removeSubModel(self.submodel2)
+        self.submodel2 = self.addSubModel(Processor())
+        self.connectPorts(self.submodel2.outport, self.submodel3.inport)
+        self.submodel4 = self.addSubModel(CoupledProcessor(0.2, 3))
+        self.connectPorts(self.submodel3.outport, self.submodel4.inport)
+        self.submodelX = self.addSubModel(ElapsedNothing())
+        return False
+
+class ElapsedNothing(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "ElapsedNothing")
+        self.elapsed = 0.3
+        self.state = 1
+
+    def intTransition(self):
+        return 0
+
+    def timeAdvance(self):
+        return self.state if self.state > 0 else float('inf')
+
+class GeneratorDS(Generator):
+    def __init__(self):
+        Generator.__init__(self, "GEN")
+        self.elapsed = 0.5
+
+    def outputFnc(self):
+        if self.state.generated < 1:
+            return Generator.outputFnc(self)
+        else:
+            return {}
+        
+    def modelTransition(self, state):
+        if self.state.generated == 1:
+            self.removePort(self.outport)
+            del self.outport
+        return self.state.generated == 1
+
+class ClassicGenerator(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Generator")
+        self.state = None
+        self.outport = self.addOutPort("outport")
+
+    def intTransition(self):
+        return None
+
+    def outputFnc(self):
+        return {self.outport: 1}
+
+    def timeAdvance(self):
+        return 1
+
+class ClassicProcessor(AtomicDEVS):
+    def __init__(self, name):
+        AtomicDEVS.__init__(self, "Processor_%s" % name)
+        self.state = None
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        
+    def intTransition(self):
+        return None
+
+    def outputFnc(self):
+        return {self.outport: self.state}
+
+    def extTransition(self, inputs):
+        self.state = inputs[self.inport]
+        return self.state
+
+    def timeAdvance(self):
+        return (1.0 if self.state is not None else INFINITY)
+
+class ClassicCoupledProcessor(CoupledDEVS):
+    def __init__(self, it, namecounter):
+        CoupledDEVS.__init__(self, "CoupledProcessor_%s_%s" % (it, namecounter))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        if it != 0:
+            self.subproc = self.addSubModel(ClassicCoupledProcessor(it-1, 0))
+        else:
+            self.subproc = self.addSubModel(ClassicProcessor(0))
+        self.subproc2 = self.addSubModel(ClassicProcessor(1))
+        if it != 0:
+            self.subproc3 = self.addSubModel(ClassicCoupledProcessor(it-1, 2))
+        else:
+            self.subproc3 = self.addSubModel(ClassicProcessor(2))
+        self.connectPorts(self.inport, self.subproc.inport)
+        self.connectPorts(self.subproc.outport, self.subproc2.inport)
+        self.connectPorts(self.subproc2.outport, self.subproc3.inport)
+        self.connectPorts(self.subproc3.outport, self.outport)
+
+    def select(self, immChildren):
+        if self.subproc3 in immChildren:
+            return self.subproc3
+        elif self.subproc2 in immChildren:
+            return self.subproc2
+        elif self.subproc in immChildren:
+            return self.subproc
+        else:
+            return immChildren[0]
+
+class ClassicCoupled(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Coupled")
+        self.generator = self.addSubModel(ClassicGenerator())
+        self.processor = self.addSubModel(ClassicCoupledProcessor(3, 0))
+        self.connectPorts(self.generator.outport, self.processor.inport)
+
+    def select(self, immChildren):
+        if self.processor in immChildren:
+            return self.processor
+        else:
+            return immChildren[0]
+
+class RandomProcessorState(object):
+    def __init__(self, seed):
+        from pypdevs.randomGenerator import RandomGenerator
+        self.randomGenerator = RandomGenerator(seed)
+        self.queue = []
+        self.proctime = self.randomGenerator.uniform(0.3, 3.0)
+
+    def __str__(self):
+        return "Random Processor State -- " + str(self.proctime)
+
+class RandomProcessor(AtomicDEVS):
+    def __init__(self, seed):
+        AtomicDEVS.__init__(self, "RandomProcessor_" + str(seed))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.state = RandomProcessorState(seed)
+
+    def intTransition(self):
+        self.state.queue = self.state.queue[1:]
+        self.state.proctime = self.state.randomGenerator.uniform(0.3, 3.0)
+        return self.state
+
+    def extTransition(self, inputs):
+        if self.state.queue:
+            self.state.proctime -= self.elapsed
+        self.state.queue.extend(inputs[self.inport])
+        return self.state
+
+    def outputFnc(self):
+        return {self.outport: [self.state.queue[0]]}
+
+    def timeAdvance(self):
+        if self.state.queue:
+            return self.state.proctime
+        else:
+            return INFINITY
+
+class RandomCoupled(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Coupled")
+        self.generator = self.addSubModel(Generator())
+        self.processor1 = self.addSubModel(RandomProcessor(1), 1)
+        self.processor2 = self.addSubModel(RandomProcessor(2), 2)
+        self.processor3 = self.addSubModel(RandomProcessor(3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor2.outport, self.processor3.inport)
+
+class RandomCoupled_local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Coupled")
+        self.generator = self.addSubModel(Generator())
+        self.processor1 = self.addSubModel(RandomProcessor(1))
+        self.processor2 = self.addSubModel(RandomProcessor(2))
+        self.processor3 = self.addSubModel(RandomProcessor(3))
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor2.outport, self.processor3.inport)
+
+class Chain_bad(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Chain")
+        self.generator = self.addSubModel(CoupledGenerator(1.0), 0)
+        self.processor1 = self.addSubModel(CoupledProcessor(0.66, 2), 1)
+        self.processor2 = self.addSubModel(CoupledProcessor(0.66, 3), 2)
+        self.processor3 = self.addSubModel(CoupledProcessor(0.66, 4), 1)
+        self.processor4 = self.addSubModel(CoupledProcessor(0.66, 5), 0)
+        self.processor5 = self.addSubModel(CoupledProcessor(0.30, 6), 2)
+        self.connectPorts(self.generator.outport, self.processor1.inport)
+        self.connectPorts(self.processor1.outport, self.processor2.inport)
+        self.connectPorts(self.processor2.outport, self.processor3.inport)
+        self.connectPorts(self.processor3.outport, self.processor4.inport)
+        self.connectPorts(self.processor4.outport, self.processor5.inport)
+
+class GeneratorClassic(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Gen")
+        self.outport = self.addOutPort("outport")
+        self.state = True
+
+    def intTransition(self):
+        return False
+
+    def outputFnc(self):
+        return {self.outport: 3}
+
+    def timeAdvance(self):
+        return 1.0 if self.state else INFINITY
+
+class ProcessorClassic1(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "P1")
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+        self.state = None
+
+    def intTransition(self):
+        return None
+
+    def extTransition(self, inputs):
+        return inputs[self.inport]
+
+    def outputFnc(self):
+        return {self.outport: self.state}
+
+    def timeAdvance(self):
+        return 1.0 if self.state is not None else INFINITY
+
+class ProcessorClassic2(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "P2")
+        self.inport1 = self.addInPort("inport1")
+        self.inport2 = self.addInPort("inport2")
+        self.outport = self.addOutPort("outport")
+        self.state = (None, None)
+
+    def intTransition(self):
+        return (None, None)
+
+    def extTransition(self, inputs):
+        inp1 = inputs.get(self.inport1, None)
+        inp2 = inputs.get(self.inport2, None)
+        return (inp1, inp2)
+
+    def outputFnc(self):
+        return {self.outport: self.state}
+
+    def timeAdvance(self):
+        return 1.0 if self.state[0] is not None or self.state[1] is not None else INFINITY
+
+class ProcessorClassicO2(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "PO2")
+        self.inport = self.addInPort("inport")
+        self.outport1 = self.addOutPort("outport1")
+        self.outport2 = self.addOutPort("outport2")
+        self.state = None
+
+    def intTransition(self):
+        return None
+
+    def extTransition(self, inputs):
+        return inputs[self.inport]
+
+    def outputFnc(self):
+        return {self.outport1: self.state, self.outport2: self.state}
+
+    def timeAdvance(self):
+        return 1.0 if self.state is not None else INFINITY
+
+class ProcessorCoupledClassic(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Coupled")
+        self.inport1 = self.addInPort("inport1")
+        self.inport2 = self.addInPort("inport2")
+        self.outport = self.addOutPort("outport")
+
+        self.proc1 = self.addSubModel(ProcessorClassic1())
+        self.proc2 = self.addSubModel(ProcessorClassic1())
+
+        self.connectPorts(self.inport1, self.proc1.inport)
+        self.connectPorts(self.inport2, self.proc2.inport)
+        self.connectPorts(self.proc1.outport, self.outport)
+        self.connectPorts(self.proc2.outport, self.outport)
+
+class AllConnectClassic(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "Root")
+        self.model1 = self.addSubModel(GeneratorClassic())
+        self.model2 = self.addSubModel(ProcessorCoupledClassic())
+        self.model3 = self.addSubModel(ProcessorClassic2())
+        self.model4 = self.addSubModel(ProcessorClassic1())
+        self.model5 = self.addSubModel(ProcessorClassicO2())
+        self.connectPorts(self.model1.outport, self.model2.inport1)
+        self.connectPorts(self.model1.outport, self.model2.inport2)
+        self.connectPorts(self.model2.outport, self.model3.inport1)
+        self.connectPorts(self.model2.outport, self.model3.inport2)
+        self.connectPorts(self.model3.outport, self.model5.inport)
+        self.connectPorts(self.model2.outport, self.model4.inport)
+        self.connectPorts(self.model4.outport, self.model5.inport)
+
+def trans1(inp):
+    inp.eventSize += 1
+    return inp
+
+def trans2(inp):
+    inp.eventSize = 0
+    return inp
+
+class ZCoupledProcessor(CoupledDEVS):
+    def __init__(self, num):
+        CoupledDEVS.__init__(self, "CoupledProcessor_" + str(num))
+        self.inport = self.addInPort("inport")
+        self.outport = self.addOutPort("outport")
+
+        self.coupled = []
+        levels = 4
+        for i in range(levels):
+            self.coupled.append(self.addSubModel(Processor("Processor" + str(i), 1.0)))
+        for i in range(levels-1):
+            self.connectPorts(self.coupled[i].outport, self.coupled[i+1].inport, trans1)
+        self.connectPorts(self.inport, self.coupled[0].inport)
+        self.connectPorts(self.coupled[-1].outport, self.outport)
+
+class ZChain_local(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ROOT")
+        self.gen = self.addSubModel(Generator())
+        self.proc1 = self.addSubModel(ZCoupledProcessor(1))
+        self.proc2 = self.addSubModel(ZCoupledProcessor(2))
+
+        self.connectPorts(self.gen.outport, self.proc1.inport)
+        self.connectPorts(self.gen.outport, self.proc2.inport, trans2)
+
+class ZChain(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "ROOT")
+        self.gen = self.addSubModel(Generator())
+        self.proc1 = self.addSubModel(ZCoupledProcessor(1), 1)
+        self.proc2 = self.addSubModel(ZCoupledProcessor(2), 2)
+
+        self.connectPorts(self.gen.outport, self.proc1.inport)
+        self.connectPorts(self.gen.outport, self.proc2.inport, trans2)