Add tutorial models

examples/tutorial_classic/atomic_ext.py

@@ -0,0 +1,53 @@
+### Model
+from pypdevs.DEVS import *
+from pypdevs.infinity import INFINITY
+
+class TrafficLight(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Light")
+        self.state = "green"
+        self.elapsed = 0.0
+        self.observe = self.addOutPort("observer")
+        self.interrupt = self.addInPort("interrupt")
+
+    def intTransition(self):
+        state = self.state
+        return {"red": "green",
+            "yellow": "red",
+            "green": "yellow"}[state]
+
+    def timeAdvance(self):
+        state = self.state
+        return {"red": 60,
+            "yellow": 3,
+            "green": 57,
+            "manual": INFINITY}[state]
+
+    def outputFnc(self):
+        state = self.state
+        if state == "red":
+            return {self.observe: "show_green"}
+        elif state == "yellow":
+            return {self.observe: "show_red"}
+        elif state == "green":
+            return {self.observe: "show_yellow"}
+
+    def extTransition(self, inputs):
+        inp = inputs[self.interrupt]
+        if inp == "manual":
+            return "manual"
+        elif inp == "auto":
+            if self.state == "manual":
+                return "red"
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLight()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+sim.setClassicDEVS()
+
+sim.simulate()

examples/tutorial_classic/atomic_int.py

@@ -0,0 +1,32 @@
+### Model
+from pypdevs.DEVS import *
+
+class TrafficLightAutonomous(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Light")
+        self.state = "green"
+        self.elapsed = 0.0
+
+    def intTransition(self):
+        state = self.state
+        return {"red": "green",
+                "yellow": "red",
+                "green": "yellow"}[state]
+
+    def timeAdvance(self):
+        state = self.state
+        return {"red": 60,
+                "yellow": 3,
+                "green": 57}[state]
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLightAutonomous()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+sim.setClassicDEVS()
+
+sim.simulate()

examples/tutorial_classic/atomic_out.py

@@ -0,0 +1,42 @@
+### Model
+from pypdevs.DEVS import *
+
+class TrafficLightWithOutput(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Light")
+        self.state = "green"
+        self.elapsed = 0.0
+        self.observe = self.addOutPort("observer")
+
+    def intTransition(self):
+        state = self.state
+        return {"red": "green",
+                "yellow": "red",
+                "green": "yellow"}[state]
+
+    def timeAdvance(self):
+        state = self.state
+        return {"red": 60,
+                "yellow": 3,
+                "green": 57}[state]
+
+    def outputFnc(self):
+        state = self.state
+        if state == "red":
+            return {self.observe: "show_green"}
+        elif state == "yellow":
+            return {self.observe: "show_red"}
+        elif state == "green":
+            return {self.observe: "show_yellow"}
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLightWithOutput()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+sim.setClassicDEVS()
+
+sim.simulate()

examples/tutorial_classic/mymodel.py

@@ -0,0 +1,5 @@
+from pypdevs.DEVS import AtomicDEVS
+
+class MyModel(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "example")

examples/tutorial_classic/policeman.py

@@ -0,0 +1,26 @@
+from pypdevs.DEVS import *
+
+class Policeman(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "policeman")
+        self.out = self.addOutPort("output")
+        self.state = "idle"
+        self.elapsed = 0.0
+
+    def intTransition(self):
+        if self.state == "idle":
+            return "working"
+        elif self.state == "working":
+            return "idle"
+
+    def timeAdvance(self):
+        if self.state == "idle":
+            return 300
+        elif self.state == "working":
+            return 3600
+
+    def outputFnc(self):
+        if self.state == "idle":
+            return {self.out: "go_to_work"}
+        elif self.state == "working":
+            return {self.out: "take_break"}

examples/tutorial_classic/simple_experiment.py

@@ -0,0 +1,11 @@
+from pypdevs.simulator import Simulator
+
+from mymodel import MyModel
+
+model = MyModel()
+simulator = Simulator(model)
+
+simulator.setVerbose()
+simulator.setClassicDEVS()
+
+simulator.simulate()

examples/tutorial_classic/trafficlight.py

@@ -0,0 +1,48 @@
+from pypdevs.DEVS import *
+from pypdevs.infinity import INFINITY
+
+class TrafficLight(AtomicDEVS):
+    def __init__(self):
+        AtomicDEVS.__init__(self, "Light")
+        self.state = "green"
+        self.elapsed = 0.0
+        self.observe = self.addOutPort("observer")
+        self.interrupt = self.addInPort("interrupt")
+
+    def intTransition(self):
+        state = self.state
+        return {"red": "green",
+                "yellow": "red",
+                "green": "yellow",
+                "going_manual": "manual",
+                "going_auto": "red"}[state]
+
+    def timeAdvance(self):
+        state = self.state
+        return {"red": 60,
+                "yellow": 3,
+                "green": 57,
+                "manual": INFINITY,
+                "going_manual": 0,
+                "going_auto": 0}[state]
+
+    def outputFnc(self):
+        state = self.state
+        if state == "red":
+            return {self.observe: "show_green"}
+        elif state == "yellow":
+            return {self.observe: "show_red"}
+        elif state == "green":
+            return {self.observe: "show_yellow"}
+        elif state == "going_manual":
+            return {self.observe: "turn_off"}
+        elif state == "going_auto":
+            return {self.observe: "show_red"}
+
+    def extTransition(self, inputs):
+        inp = inputs[self.interrupt]
+        if inp == "toManual":
+            return "going_manual"
+        elif inp == "toAuto":
+            if self.state == "manual":
+                return "going_auto"

examples/tutorial_classic/trafficlight_system.py

@@ -0,0 +1,32 @@
+### Model
+from pypdevs.DEVS import *
+
+from trafficlight import TrafficLight
+from policeman import Policeman
+
+def convert_police2light(evt):
+    if evt == "take_break":
+        return "toAuto"
+    elif evt == "go_to_work":
+        return "toManual"
+
+class TrafficLightSystem(CoupledDEVS):
+    def __init__(self):
+        CoupledDEVS.__init__(self, "system")
+        self.light = self.addSubModel(TrafficLight())
+        self.police = self.addSubModel(Policeman())
+        self.connectPorts(self.police.out, self.light.interrupt, convert_police2light)
+
+    def select(self, imm):
+        if self.police in imm:
+            return self.police
+        else:
+            return self.light
+
+### Experiment
+from pypdevs.simulator import Simulator
+sim = Simulator(TrafficLightSystem())
+sim.setVerbose()
+sim.setTerminationTime(1000)
+sim.setClassicDEVS()
+sim.simulate()

examples/tutorial_parallel/atomic_conf.py

@@ -0,0 +1,56 @@
+### Model
+from pypdevs.DEVS import *
+
+class TrafficLight(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "Light")
+		self.state = "green"
+		self.observe = self.addOutPort("observer")
+		self.interrupt = self.addInPort("interrupt")
+
+	def intTransition(self):
+		state = self.state
+		return {"red": "green",
+			"yellow": "red",
+			"green": "yellow"}[state]
+
+	def timeAdvance(self):
+		state = self.state
+		return {"red": 60,
+			"yellow": 3,
+			"green": 57}[state]
+
+	def outputFnc(self):
+		state = self.state
+		if state == "red":
+			v = "green"
+		elif state == "yellow":
+			v = "red"
+		elif state == "green":
+			v = "yellow"
+		return {self.observe: [v]}
+
+	def extTransition(self, inputs):
+		inp = inputs[self.interrupt][0]
+		if inp == "manual":
+			return "manual"
+		elif inp == "auto":
+			if self.state == "manual":
+				return "red"
+
+	def confTransition(self, inputs):
+		self.elapsed = 0.0
+		self.state = self.intTransition()
+		self.state = self.extTransition(inputs)
+		return self.state
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLight()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+
+sim.simulate()

examples/tutorial_parallel/atomic_ext.py

@@ -0,0 +1,52 @@
+### Model
+from pypdevs.DEVS import *
+from pypdevs.infinity import INFINITY
+
+class TrafficLight(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "Light")
+		self.state = "green"
+		self.observe = self.addOutPort("observer")
+		self.interrupt = self.addInPort("interrupt")
+
+	def intTransition(self):
+		state = self.state
+		return {"red": "green",
+			"yellow": "red",
+			"green": "yellow"}[state]
+
+	def timeAdvance(self):
+		state = self.state
+		return {"red": 60,
+			"yellow": 3,
+			"green": 57,
+			"manual": INFINITY}[state]
+
+	def outputFnc(self):
+		state = self.state
+		if state == "red":
+			v = "green"
+		elif state == "yellow":
+			v = "red"
+		elif state == "green":
+			v = "yellow"
+		return {self.observe: [v]}
+
+	def extTransition(self, inputs):
+		inp = inputs[self.interrupt][0]
+		if inp == "manual":
+			return "manual"
+		elif inp == "auto":
+			if self.state == "manual":
+				return "red"
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLight()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+
+sim.simulate()

examples/tutorial_parallel/atomic_int.py

@@ -0,0 +1,30 @@
+### Model
+from pypdevs.DEVS import *
+
+class TrafficLightAutonomous(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "Light")
+		self.state = "green"
+
+	def intTransition(self):
+		state = self.state
+		return {"red": "green",
+			"yellow": "red",
+			"green": "yellow"}[state]
+
+	def timeAdvance(self):
+		state = self.state
+		return {"red": 60,
+			"yellow": 3,
+			"green": 57}[state]
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLightAutonomous()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+
+sim.simulate()

examples/tutorial_parallel/atomic_out.py

@@ -0,0 +1,41 @@
+### Model
+from pypdevs.DEVS import *
+
+class TrafficLightWithOutput(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "Light")
+		self.state = "green"
+		self.observe = self.addOutPort("observer")
+
+	def intTransition(self):
+		state = self.state
+		return {"red": "green",
+			"yellow": "red",
+			"green": "yellow"}[state]
+
+	def timeAdvance(self):
+		state = self.state
+		return {"red": 60,
+			"yellow": 3,
+			"green": 57}[state]
+
+	def outputFnc(self):
+		state = self.state
+		if state == "red":
+			v = "green"
+		elif state == "yellow":
+			v = "red"
+		elif state == "green":
+			v = "yellow"
+		return {self.observe: [v]}
+
+### Experiment
+from pypdevs.simulator import Simulator
+
+model = TrafficLightWithOutput()
+sim = Simulator(model)
+
+sim.setVerbose()
+sim.setTerminationTime(500)
+
+sim.simulate()

examples/tutorial_parallel/mymodel.py

@@ -0,0 +1,5 @@
+from pypdevs.DEVS import AtomicDEVS
+
+class MyModel(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "example")

examples/tutorial_parallel/policeman.py

@@ -0,0 +1,25 @@
+from pypdevs.DEVS import *
+
+class Policeman(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "policeman")
+		self.out = self.addOutPort("output")
+		self.state = "idle"
+
+	def intTransition(self):
+		if self.state == "idle":
+			return "working"
+		elif self.state == "working":
+			return "idle"
+
+	def timeAdvance(self):
+		if self.state == "idle":
+			return 20
+		elif self.state == "working":
+			return 360
+
+	def outputFnc(self):
+		if self.state == "idle":
+			return {self.out: ["manual"]}
+		elif self.state == "working":
+			return {self.out: ["auto"]}

examples/tutorial_parallel/simple_experiment.py

@@ -0,0 +1,10 @@
+from pypdevs.simulator import Simulator
+
+from mymodel import MyModel
+
+model = MyModel()
+simulator = Simulator(model)
+
+simulator.setVerbose()
+
+simulator.simulate()

examples/tutorial_parallel/trafficlight.py

@@ -0,0 +1,46 @@
+from pypdevs.DEVS import *
+from pypdevs.infinity import INFINITY
+
+class TrafficLight(AtomicDEVS):
+	def __init__(self):
+		AtomicDEVS.__init__(self, "Light")
+		self.state = "green"
+		self.observe = self.addOutPort("observer")
+		self.interrupt = self.addInPort("interrupt")
+
+	def intTransition(self):
+		state = self.state
+		return {"red": "green",
+			"yellow": "red",
+			"green": "yellow"}[state]
+
+	def timeAdvance(self):
+		state = self.state
+		return {"red": 60,
+			"yellow": 3,
+			"green": 57,
+			"manual": INFINITY}[state]
+
+	def outputFnc(self):
+		state = self.state
+		if state == "red":
+			v = "green"
+		elif state == "yellow":
+			v = "red"
+		elif state == "green":
+			v = "yellow"
+		return {self.observe: [v]}
+
+	def extTransition(self, inputs):
+		inp = inputs[self.interrupt][0]
+		if inp == "manual":
+			return "manual"
+		elif inp == "auto":
+			if self.state == "manual":
+				return "red"
+
+	def confTransition(self, inputs):
+		self.elapsed = 0.0
+		self.state = self.intTransition()
+		self.state = self.extTransition(inputs)
+		return self.state

examples/tutorial_parallel/trafficlight_system.py

@@ -0,0 +1,19 @@
+### Model
+from pypdevs.DEVS import *
+
+from trafficlight import TrafficLight
+from policeman import Policeman
+
+class TrafficLightSystem(CoupledDEVS):
+	def __init__(self):
+		CoupledDEVS.__init__(self, "system")
+		self.light = self.addSubModel(TrafficLight())
+		self.police = self.addSubModel(Policeman())
+		self.connectPorts(self.police.out, self.light.interrupt)
+
+### Experiment
+from pypdevs.simulator import Simulator
+sim = Simulator(TrafficLightSystem())
+sim.setVerbose()
+sim.setTerminationTime(1000)
+sim.simulate()