Changed structure of the original sccd compiler to support DEVS

DEVSbuilder/builtDEVS.py

@@ -1,133 +0,0 @@
-# Import the model to be simulated
-from sccd.compiler.sccdc import xmlToSccd
-
-
-def build_statechart(root, statechart_string=""):
-    if root.is_parallel_state:
-        for child in root.children:
-            statechart_string += build_statechart(child)
-        statechart_string += f"{root.full_name} = ParallelState(["
-        for child in root.children:
-            statechart_string += child.full_name + ", "
-        statechart_string = statechart_string[:-2]
-        statechart_string += f"])\n"
-    elif root.is_composite:
-        for child in root.children:
-            statechart_string += build_statechart(child)
-
-        statechart_string += f"{root.full_name} = CompositeState("
-        for child in root.children:
-            if child.new_full_name == root.initial:
-                statechart_string += child.full_name
-        statechart_string += f")\n"
-    elif root.is_basic:
-        statechart_string += f"{root.full_name} = State()\n"
-    return statechart_string
-
-def build_statechart_transitions(root, statechart_string=""):
-    for child in root.children:
-        statechart_string += build_statechart_transitions(child)
-    for transition in root.transitions:
-        statechart_string += f"Transition(None, {root.full_name}, {transition.target.target_nodes[0].full_name})\n"
-    return statechart_string
-
-
-
-sccdObject = xmlToSccd("../input.xml")
-print("")
-with open('output/DEVS.py', 'w') as file:
-    file.write("from pypdevs.DEVS import *\n"
-               "from pypdevs.infinity import INFINITY\n"
-               "from ..statecharts_core import *")
-    file.write(sccdObject.top.replace('\t', '') + "\n")
-
-    # Define the Coupled DEVS
-    file.write("\nclass SCCD(CoupledDEVS):\n"
-               "\tdef __init__(self):\n"
-               "\t\tCoupledDEVS.__init__(self)\n")
-
-    file.write("\n")
-
-    # Define in- and outports
-    file.write("\t\tself.inports = []\n")
-    file.write(f"\t\tfor inport in range({len(sccdObject.inports)}):\n")
-    file.write(f"\t\t\tself.inports.append(self.addInPort())\n")
-    file.write("\n")
-    file.write("\t\tself.outports = []\n")
-    file.write(f"\t\tfor outport in range({len(sccdObject.outports)}):\n")
-    file.write(f"\t\t\tself.outports.append(self.addOutPort())\n")
-    file.write("\n")
-
-    # Define the atomic DEVS in the coupled DEVS
-    for sccd_class in sccdObject.classes:
-        file.write(f"\t\t{sccd_class.name.lower()} = self.addSubModel({sccd_class.name}())\n")
-
-    file.write("\n")
-    # Define the links between the classes
-    for sccd_class in sccdObject.classes:
-        for association in sccd_class.associations:
-            file.write(f"\t\tself.connectPorts({sccd_class.name.lower()}.outport, {association.to_class.lower()}.inport)\n")
-
-    for sccd_class in sccdObject.classes:
-        # Define an instance state
-        file.write(f"\n\nclass {sccd_class.name}State:\n")
-
-        file.write("\tdef __init__(self")
-        for constructor in sccd_class.constructors:
-            for parameter in constructor.parameters:
-                file.write(f", {parameter.identifier}")
-                if parameter.default is not None:
-                    file.write(f"= {parameter.default}")
-        file.write(f"):")
-
-        for constructor in sccd_class.constructors:
-            file.write(f"{constructor.body.replace("\t\t\t\t", "\t\t")}")
-
-        # Define user-defined Statechart model
-        file.write("\n")
-        statechart_model = build_statechart(sccd_class.statechart.root)
-        statechart_model += build_statechart_transitions(sccd_class.statechart.root)
-        statechart_model = "\t\t" + statechart_model.replace("\n", "\n\t\t")
-        file.write(statechart_model)
-
-        file.write("\n")
-        # Define user-defined methods
-        for method in sccd_class.methods:
-            file.write(f"\tdef {method.name}(self):")
-            file.write(method.body.replace("\t\t\t\t", "\t\t"))
-
-
-
-        # Define all classes as atomic DEVS
-        file.write(f"\n\nclass {sccd_class.name}(AtomicDEVS):\n"
-                   f"\tdef __init__(self):\n"
-                   f"\t\tAtomicDEVS.__init__(self)\n")
-
-        # Define time to check
-        if sccd_class == sccdObject.default_class:
-            file.write(f"\t\tself.advance = 0\n")
-        else:
-            file.write(f"\t\tself.advance = INFINITY\n")
-
-        # Define the state: statechart, methods, and parameters
-        file.write(f"\t\tself.state = [")
-        if sccd_class == sccdObject.default_class:
-            # TODO: Parameters on initialization?
-            file.write(f"{sccd_class.name}State()")
-        file.write(f"]\n")
-
-        file.write("\n")
-        # Define DEVS methods
-        file.write("\tdef timeAdvance(self):\n"
-                   "\t\tpass\n")
-        file.write("\tdef extTransition(self, inputs):\n"
-                   "\t\tpass\n")
-        file.write("\tdef intTransition(self):\n"
-                   "\t\tpass\n")
-        file.write("\tdef outputFnc(self):\n"
-                   "\t\tpass\n")
-
-
-
-
-print("File writing complete.")

DEVSbuilder/output/DEVS.py

@@ -1,212 +0,0 @@
-from pypdevs.DEVS import *
-from pypdevs.infinity import INFINITY
-from ..statecharts_core import *
-import time
-import random
-import tk
-from mvk_widget import MvKWidget
-
-
-class SCCD(CoupledDEVS):
-	def __init__(self):
-		CoupledDEVS.__init__(self)
-
-		self.inports = []
-		for inport in range(1):
-			self.inports.append(self.addInPort())
-
-		self.outports = []
-		for outport in range(0):
-			self.outports.append(self.addOutPort())
-
-		mainapp = self.addSubModel(MainApp())
-		field = self.addSubModel(Field())
-		button = self.addSubModel(Button())
-		ball = self.addSubModel(Ball())
-
-		self.connectPorts(mainapp.outport, field.inport)
-		self.connectPorts(field.outport, ball.inport)
-		self.connectPorts(field.outport, button.inport)
-		self.connectPorts(field.outport, mainapp.inport)
-		self.connectPorts(button.outport, field.inport)
-		self.connectPorts(ball.outport, field.inport)
-
-
-class MainAppState:
-	def __init__(self):
-		tk.Tk.__init__(self)
-		self.fixed_update_time = 20
-		self.update_self()
-		self.withdraw()
-		self.nr_of_fields = 0
-			
-		Root_running_root_main_behaviour_initializing = State()
-		Root_running_root_main_behaviour_running = State()
-		Root_running_root_main_behaviour = CompositeState(Root_running_root_main_behaviour_initializing)
-		Root_running_root_cd_behaviour_waiting = State()
-		Root_running_root_cd_behaviour_creating = State()
-		Root_running_root_cd_behaviour_check_nr_of_fields = State()
-		Root_running_root_cd_behaviour = CompositeState(Root_running_root_cd_behaviour_waiting)
-		Root_running_root = ParallelState([Root_running_root_main_behaviour, Root_running_root_cd_behaviour])
-		Root_running_stopped = State()
-		Root_running = CompositeState(Root_running_root)
-		Root = CompositeState(Root_running)
-
-		Transition(None, Root_running_root_main_behaviour_initializing, Root_running_root_main_behaviour_running)
-		Transition(None, Root_running_root_main_behaviour_running, Root_running_root_main_behaviour_running)
-		Transition(None, Root_running_root_cd_behaviour_waiting, Root_running_root_cd_behaviour_creating)
-		Transition(None, Root_running_root_cd_behaviour_waiting, Root_running_root_cd_behaviour_check_nr_of_fields)
-		Transition(None, Root_running_root_cd_behaviour_creating, Root_running_root_cd_behaviour_waiting)
-		Transition(None, Root_running_root_cd_behaviour_check_nr_of_fields, Root_running_stopped)
-		Transition(None, Root_running_root_cd_behaviour_check_nr_of_fields, Root_running_root_cd_behaviour_waiting)
-		
-	def update_self(self):
-		self.controller.update(self.fixed_update_time / 1000.0)
-		self.schedule_time = time.time()
-		self.scheduled_update_id = self.after(self.fixed_update_time, self.update_self)
-			
-
-class MainApp(AtomicDEVS):
-	def __init__(self):
-		AtomicDEVS.__init__(self)
-		self.advance = 0
-		self.state = [MainAppState()]
-
-	def timeAdvance(self):
-		pass
-	def extTransition(self, inputs):
-		pass
-	def intTransition(self):
-		pass
-	def outputFnc(self):
-		pass
-
-
-class FieldState:
-	def __init__(self):
-		
-		tk.Toplevel.__init__(self)
-		self.title('BouncingBalls')
-
-		CANVAS_SIZE_TUPLE = (0, 0, self.winfo_screenwidth() * 2, self.winfo_screenheight() * 2)
-		self.c = tk.Canvas(self, relief=tk.RIDGE, scrollregion=CANVAS_SIZE_TUPLE)
-
-		MvKWidget.__init__(self, self.controller, self.c)
-		
-			
-		Root_root_waiting = State()
-		Root_root_initializing = State()
-		Root_root_creating = State()
-		Root_root_packing = State()
-		Root_root_running_main_behaviour_running = State()
-		Root_root_running_main_behaviour_creating = State()
-		Root_root_running_main_behaviour = CompositeState(Root_root_running_main_behaviour_running)
-		Root_root_running_deleting_behaviour_running = State()
-		Root_root_running_deleting_behaviour = CompositeState(Root_root_running_deleting_behaviour_running)
-		Root_root_running_child_behaviour_listening = State()
-		Root_root_running_child_behaviour = CompositeState(Root_root_running_child_behaviour_listening)
-		Root_root_running = ParallelState([Root_root_running_main_behaviour, Root_root_running_deleting_behaviour, Root_root_running_child_behaviour])
-		Root_root_deleting = State()
-		Root_root_deleted = State()
-		Root_root = CompositeState(Root_root_waiting)
-		Root = CompositeState(Root_root)
-		Transition(None, Root_root_waiting, Root_root_initializing)
-		Transition(None, Root_root_initializing, Root_root_creating)
-		Transition(None, Root_root_creating, Root_root_packing)
-		Transition(None, Root_root_packing, Root_root_running)
-		Transition(None, Root_root_running_main_behaviour_running, Root_root_running_main_behaviour_creating)
-		Transition(None, Root_root_running_main_behaviour_creating, Root_root_running_main_behaviour_running)
-		Transition(None, Root_root_running_deleting_behaviour_running, Root_root_running_deleting_behaviour_running)
-		Transition(None, Root_root_running_child_behaviour_listening, Root_root_running_child_behaviour_listening)
-		Transition(None, Root_root_running, Root_root_deleting)
-		Transition(None, Root_root_deleting, Root_root_deleted)
-		
-
-
-class Field(AtomicDEVS):
-	def __init__(self):
-		AtomicDEVS.__init__(self)
-		self.advance = INFINITY
-		self.state = []
-
-	def timeAdvance(self):
-		pass
-	def extTransition(self, inputs):
-		pass
-	def intTransition(self):
-		pass
-	def outputFnc(self):
-		pass
-
-
-class ButtonState:
-	def __init__(self, parent, event_name, button_text):
-		tk.Button.__init__(self, parent, text=button_text)
-		MvKWidget.__init__(self, self.controller)
-		self.event_name = event_name
-			
-		Root_initializing = State()
-		Root_running = State()
-		Root = CompositeState(Root_initializing)
-		Transition(None, Root_initializing, Root_running)
-		Transition(None, Root_running, Root_running)
-		
-
-
-class Button(AtomicDEVS):
-	def __init__(self):
-		AtomicDEVS.__init__(self)
-		self.advance = INFINITY
-		self.state = []
-
-	def timeAdvance(self):
-		pass
-	def extTransition(self, inputs):
-		pass
-	def intTransition(self):
-		pass
-	def outputFnc(self):
-		pass
-
-
-class BallState:
-	def __init__(self, canvas, x, y):
-		self.canvas = canvas
-		self.r = 15.0
-		self.smooth = 0.4 # value between 0 and 1
-		self.vel = {'x': random.random() * 2.0 - 1.0, 'y': random.random() * 2.0 - 1.0}
-		self.id = self.canvas.create_oval(x, y, x + (self.r * 2), y + (self.r * 2), fill="black")
-		MvKWidget.__init__(self, self.controller, self.canvas, self.id)
-			
-		Root_main_behaviour_initializing = State()
-		Root_main_behaviour_bouncing = State()
-		Root_main_behaviour_dragging = State()
-		Root_main_behaviour_selected = State()
-		Root_main_behaviour = CompositeState(Root_main_behaviour_initializing)
-		Root_deleted = State()
-		Root = CompositeState(Root_main_behaviour)
-		Transition(None, Root_main_behaviour_initializing, Root_main_behaviour_bouncing)
-		Transition(None, Root_main_behaviour_bouncing, Root_main_behaviour_bouncing)
-		Transition(None, Root_main_behaviour_bouncing, Root_main_behaviour_selected)
-		Transition(None, Root_main_behaviour_dragging, Root_main_behaviour_dragging)
-		Transition(None, Root_main_behaviour_dragging, Root_main_behaviour_bouncing)
-		Transition(None, Root_main_behaviour_selected, Root_main_behaviour_dragging)
-		Transition(None, Root_main_behaviour_selected, Root_main_behaviour_selected)
-		Transition(None, Root_main_behaviour, Root_deleted)
-		
-
-
-class Ball(AtomicDEVS):
-	def __init__(self):
-		AtomicDEVS.__init__(self)
-		self.advance = INFINITY
-		self.state = []
-
-	def timeAdvance(self):
-		pass
-	def extTransition(self, inputs):
-		pass
-	def intTransition(self):
-		pass
-	def outputFnc(self):
-		pass

DEVSbuilder/statecharts_core.py

@@ -1,107 +0,0 @@
-class State:
-    def __init__(self):
-        self.ancestors = []
-        self.descendants = []
-        self.descendant_bitmap = 0
-        self.children = []
-        self.parent = None
-        self.enter = None
-        self.exit = None
-        self.default_state = None
-        self.transitions = []
-        self.history = []
-        self.has_eventless_transitions = False
-
-    def getEffectiveTargetStates(self):
-        pass
-
-    def fixTree(self):
-        pass
-
-    def addChild(self, child):
-        self.children.append(child)
-
-    def addTransition(self, transition):
-        self.transitions.append(transition)
-
-    def setEnter(self, enter):
-        self.enter = enter
-
-    def setExit(self, exit):
-        self.exit = exit
-
-class CompositeState(State):
-    def __init__(self, start_state):
-        State.__init__(self)
-
-
-class HistoryState(State):
-    def __init__(self, state_id, obj):
-        State.__init__(self)
-
-
-class ShallowHistoryState(HistoryState):
-    def __init__(self, state_id, obj):
-        HistoryState.__init__(self, state_id, obj)
-
-    def getEffectiveTargetStates(self):
-        pass
-
-
-class DeepHistoryState(HistoryState):
-    def __init__(self, state_id, obj):
-        HistoryState.__init__(self, state_id, obj)
-
-    def getEffectiveTargetStates(self):
-        pass
-
-class ParallelState(State):
-    def __init__(self, state_id, obj):
-        State.__init__(self)
-
-    def getEffectiveTargetStates(self):
-        pass
-
-
-class Transition:
-    def __init__(self, source, targets):
-        self.guard = None
-        self.action = None
-        self.trigger = None
-        self.source = source
-        self.targets = targets
-        self.enabled_event = None  # the event that enabled this transition
-        self.optimize()
-
-    def isEnabled(self, events):
-        pass
-
-    # @profile
-    def fire(self):
-        pass
-
-    def __getEffectiveTargetStates(self):
-        pass
-
-    def __exitSet(self, targets):
-        pass
-
-    def __enterSet(self, targets):
-        pass
-
-    def setGuard(self, guard):
-        self.guard = guard
-
-    def setAction(self, action):
-        self.action = action
-
-    def setTrigger(self, trigger):
-        self.trigger = trigger
-        if self.trigger is None:
-            self.source.has_eventless_transitions = True
-
-    def optimize(self):
-        pass
-
-    def __repr__(self):
-        return "Transition(%s, %s)" % (self.source, self.targets[0])

experiment.py

@@ -1,62 +0,0 @@
-# Import code for model simulation:
-from pypdevs.simulator import Simulator
-
-# Import the model to be simulated
-from sccd.compiler.sccdc import xmlToSccd
-from sccdDEV import SCCD
-
-#    ======================================================================
-
-# 1. Instantiate the (Coupled or Atomic) DEVS at the root of the
-#  hierarchical model. This effectively instantiates the whole model
-#  thanks to the recursion in the DEVS model constructors (__init__).
-#
-sccdObject = xmlToSccd("input.xml")
-sccdDEV = SCCD(sccdObject)
-
-#    ======================================================================
-
-# 2. Link the model to a DEVS Simulator:
-#  i.e., create an instance of the 'Simulator' class,
-#  using the model as a parameter.
-sim = Simulator(sccdDEV)
-
-#    ======================================================================
-
-# 3. Perform all necessary configurations, the most commonly used are:
-
-# A. Termination time (or termination condition)
-#    Using a termination condition will execute a provided function at
-#    every simulation step, making it possible to check for certain states
-#    being reached.
-#    It should return True to stop simulation, or Falso to continue.
-#def terminate_whenStateIsReached(clock, model):
-#    return model.trafficLight.state.get() == "manual"
-#sim.setTerminationCondition(terminate_whenStateIsReached)
-
-#    A termination time is prefered over a termination condition,
-#    as it is much simpler to use.
-#    e.g. to simulate until simulation time 400.0 is reached
-sim.setTerminationTime(400.0)
-
-# B. Set the use of a tracer to show what happened during the simulation run
-#    Both writing to stdout or file is possible:
-#    pass None for stdout, or a filename for writing to that file
-sim.setVerbose("Trace.txt")
-
-# C. Use Classic DEVS instead of Parallel DEVS
-#    If your model uses Classic DEVS, this configuration MUST be set as
-#    otherwise errors are guaranteed to happen.
-#    Without this option, events will be remapped and the select function
-#    will never be called.
-sim.setClassicDEVS()
-
-#    ======================================================================
-
-# 4. Simulate the model
-sim.simulate()
-
-#    ======================================================================
-
-# 5. (optional) Extract data from the simulated model
-print("Simulation terminated")

main.py

@@ -1,17 +0,0 @@
-# This is a sample Python script.
-
-# Press ⌃R to execute it or replace it with your code.
-# Press Double ⇧ to search everywhere for classes, files, tool windows, actions, and settings.
-
-
-def print_hi(name):
-    # Use a breakpoint in the code line below to debug your script.
-    print(f'Hi, {name}')  # Press ⌘F8 to toggle the breakpoint.
-
-
-# Press the green button in the
-# gutter to run the script.
-if __name__ == '__main__':
-    print_hi('PyCharm')
-
-# See PyCharm help at https://www.jetbrains.com/help/pycharm/

sccdDEV.py

@@ -1,59 +0,0 @@
-from pypdevs.DEVS import *
-from pypdevs.infinity import INFINITY
-
-
-class SCCDclass(AtomicDEVS):
-    def __init__(self, name=None, default=False):
-        AtomicDEVS.__init__(self, name)
-
-        # Every SCCD class has a connection to each class
-        self.OUT = self.addOutPort()
-        self.IN = self.addInPort()
-
-        #
-        self.state = None
-
-        # Initial SCCD class should initialize first
-        self.advance = INFINITY
-        self.default = default
-        if default:
-            self.advance = 0
-
-        self.initialized = False
-
-    def timeAdvance(self):
-        return self.advance
-
-    def extTransition(self, inputs):
-        return self.state
-
-    def intTransition(self):
-        return self.state
-
-    def outputFnc(self):
-        return {}
-
-
-class SCCD(CoupledDEVS):
-    def __init__(self, sccdObject):
-        CoupledDEVS.__init__(self, sccdObject.name)
-
-        self.inports = []
-        for _ in sccdObject.inports:
-            self.inports.append(self.addInPort())
-
-        self.outports = []
-        for _ in sccdObject.outports:
-            self.outports.append(self.addOutPort())
-
-        self.DEVclasses = []
-        for i in sccdObject.classes:
-            # Check which class is the initial/default class
-            default = (i == sccdObject.default_class)
-            DEVclass = self.addSubModel(SCCDclass(i.name, default))
-            self.DEVclasses.append(DEVclass)
-
-
-
-        #self.connectPorts(self.main.OUT, self.field.IN)
-        #self.connectPorts(self.field.OUT, self.main.IN)