diff --git a/examples/tutorial_classic/atomic_ext.py b/examples/tutorial_classic/atomic_ext.py new file mode 100644 index 0000000..a56009b --- /dev/null +++ b/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() diff --git a/examples/tutorial_classic/atomic_int.py b/examples/tutorial_classic/atomic_int.py new file mode 100644 index 0000000..841d471 --- /dev/null +++ b/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() diff --git a/examples/tutorial_classic/atomic_out.py b/examples/tutorial_classic/atomic_out.py new file mode 100644 index 0000000..972aaff --- /dev/null +++ b/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() diff --git a/examples/tutorial_classic/mymodel.py b/examples/tutorial_classic/mymodel.py new file mode 100644 index 0000000..cf19b32 --- /dev/null +++ b/examples/tutorial_classic/mymodel.py @@ -0,0 +1,5 @@ +from pypdevs.DEVS import AtomicDEVS + +class MyModel(AtomicDEVS): + def __init__(self): + AtomicDEVS.__init__(self, "example") diff --git a/examples/tutorial_classic/policeman.py b/examples/tutorial_classic/policeman.py new file mode 100644 index 0000000..dc67584 --- /dev/null +++ b/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"} diff --git a/examples/tutorial_classic/simple_experiment.py b/examples/tutorial_classic/simple_experiment.py new file mode 100644 index 0000000..fb69eca --- /dev/null +++ b/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() diff --git a/examples/tutorial_classic/trafficlight.py b/examples/tutorial_classic/trafficlight.py new file mode 100644 index 0000000..4f52210 --- /dev/null +++ b/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" diff --git a/examples/tutorial_classic/trafficlight_system.py b/examples/tutorial_classic/trafficlight_system.py new file mode 100644 index 0000000..e6226be --- /dev/null +++ b/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() diff --git a/examples/tutorial_parallel/atomic_conf.py b/examples/tutorial_parallel/atomic_conf.py new file mode 100644 index 0000000..4e3ee1f --- /dev/null +++ b/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() \ No newline at end of file diff --git a/examples/tutorial_parallel/atomic_ext.py b/examples/tutorial_parallel/atomic_ext.py new file mode 100644 index 0000000..9fffa8d --- /dev/null +++ b/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() \ No newline at end of file diff --git a/examples/tutorial_parallel/atomic_int.py b/examples/tutorial_parallel/atomic_int.py new file mode 100644 index 0000000..cd4918c --- /dev/null +++ b/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() \ No newline at end of file diff --git a/examples/tutorial_parallel/atomic_out.py b/examples/tutorial_parallel/atomic_out.py new file mode 100644 index 0000000..be35e0e --- /dev/null +++ b/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() \ No newline at end of file diff --git a/examples/tutorial_parallel/mymodel.py b/examples/tutorial_parallel/mymodel.py new file mode 100644 index 0000000..eb38625 --- /dev/null +++ b/examples/tutorial_parallel/mymodel.py @@ -0,0 +1,5 @@ +from pypdevs.DEVS import AtomicDEVS + +class MyModel(AtomicDEVS): + def __init__(self): + AtomicDEVS.__init__(self, "example") \ No newline at end of file diff --git a/examples/tutorial_parallel/policeman.py b/examples/tutorial_parallel/policeman.py new file mode 100644 index 0000000..bfdf195 --- /dev/null +++ b/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"]} \ No newline at end of file diff --git a/examples/tutorial_parallel/simple_experiment.py b/examples/tutorial_parallel/simple_experiment.py new file mode 100644 index 0000000..2b58219 --- /dev/null +++ b/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() \ No newline at end of file diff --git a/examples/tutorial_parallel/trafficlight.py b/examples/tutorial_parallel/trafficlight.py new file mode 100644 index 0000000..c05d4e1 --- /dev/null +++ b/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 \ No newline at end of file diff --git a/examples/tutorial_parallel/trafficlight_system.py b/examples/tutorial_parallel/trafficlight_system.py new file mode 100644 index 0000000..a3f82aa --- /dev/null +++ b/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() \ No newline at end of file diff --git a/src/pypdevs/DEVS.py b/src/pypdevs/DEVS.py index 38e6832..282c37b 100644 --- a/src/pypdevs/DEVS.py +++ b/src/pypdevs/DEVS.py @@ -657,10 +657,10 @@ class CoupledDEVS(BaseDEVS): " '%s' and '%s' belong to the same model" + " '%s'. " + " Direct feedback coupling not allowed") % ( - self.getModelFullName(), - p1.getPortFullName(), - p2.getPortFullName(), - p1.host_DEVS.getModelFullName())) + self.getModelName(), + p1.getPortName(), + p2.getPortName(), + p1.host_DEVS.getModelName())) else: p1.outline.append(p2) p2.inline.append(p1)