Strona główna Odkrywaj Pomoc
Zaloguj się
claudio
/
MLE
Obserwuj 1
Polub 0
Forkuj 0
Pliki Problemy 0 Oczekujące zmiany 0 Wiki
Przeglądaj źródła

parallel version finished

Simon Van Mierlo 9 lat temu
rodzic
ab16bce58b
commit
34936d21eb
2 zmienionych plików z 440 dodań i 177 usunięć
Widok podzielony Pokaż statystyki zmian
  1. 140 35
      debugging_fsa_cbd_composition/cbdsimulator/cbdsim_parallel.xml
  2. 300 142
      debugging_fsa_cbd_composition/cbdsimulator/target.py

+ 140 - 35
debugging_fsa_cbd_composition/cbdsimulator/cbdsim_parallel.xml
Wyświetl plik 

@@ -291,6 +291,8 @@
 
             <parameter name="new_val" />
 
             <body>
 
             <![CDATA[
 
+                if not self.simulationInitialized():
 
+                    return -1
 
                 if block_name not in self.state:
 
                     return -1
 
                 for b in self.model.getBlocks():
 
@@ -306,32 +308,76 @@
 
                 <parallel id="SimulationCoordinator">
 
                     <state id="ModeSelector" initial="Paused">
 
                         <state id="Paused">
 
-                            <transition target="../SmallStep" event="small_step" port="user_input" />
 
-                            <transition target="../BigStep" event="big_step" port="user_input" />
 
-                            <transition target="../Continuous" event="continuous" port="user_input" />
 
-                            <transition target="../Realtime" event="realtime" port="user_input">
 
+                            <transition target="../Running/SmallStep" event="small_step" port="user_input" />
 
+                            <transition target="../Running/BigStep" event="big_step" port="user_input" />
 
+                            <transition target="../Running/Continuous" event="continuous" port="user_input" />
 
+                            <transition target="../Running/Realtime" event="realtime" port="user_input">
 
                                 <parameter name="realtime_scale" default="1.0" />
 
                                 <script>
 
                                     self.realtime_scale = realtime_scale
 
                                 </script>
 
                             </transition>
 
                         </state>
 
-                        <state id="SmallStep">
 
-                            <transition target="../Paused" event="SmallStep.Finished" />
 
-                        </state>
 
-                        <state id="BigStep">
 
-                            <transition target="../Paused" event="BigStep.Finished" />
 
-                        </state>
 
-                        <state id="Continuous">
 
-                            <transition target="../Paused" event="Simulation.Finished" />
 
-                            <transition target="../Paused" event="pause" port="user_input">
 
-                                <raise event="Simulation.Pause" />
 
+                        <state id="Running" initial="Continuous">
 
+                            <state id="Continuous">
 
+                                <transition target="../../WaitingForPaused" event="pause" port="user_input">
 
+                                    <raise event="Simulation.Pause" />
 
+                                </transition>
 
+                            </state>
 
+                            <state id="Realtime">
 
+                                <transition target="../../WaitingForPaused" event="pause" port="user_input">
 
+                                    <raise event="Simulation.Pause" />
 
+                                </transition>
 
+                                <transition target="." event="BigStep.Finished">
 
+                                    <raise event="BigStep.Finished" port="user_output" />
 
+                                    <raise event="State" port="user_output">
 
+                                        <parameter expr="self.clock / 1000.0" />
 
+                                        <!--parameter expr="self.state" /-->
 
+                                    </raise>
 
+                                </transition>
 
+                            </state>
 
+                            <state id="BigStep">
 
+                                <transition target="../../Paused" event="BigStep.Finished">
 
+                                    <raise event="BigStep.Finished" port="user_output" />
 
+                                    <raise event="State" port="user_output">
 
+                                        <parameter expr="self.clock / 1000.0" />
 
+                                        <!--parameter expr="self.state" /-->
 
+                                    </raise>
 
+                                </transition>
 
+                            </state>
 
+                            <state id="SmallStep">
 
+                                <transition target="../../Paused" event="SmallStep.Finished">
 
+                                    <raise event="SmallStep.Finished" port="user_output" />
 
+                                    <raise event="State" port="user_output">
 
+                                        <parameter expr="self.clock / 1000.0" />
 
+                                        <!--parameter expr="self.state" /-->
 
+                                    </raise>
 
+                                </transition>
 
+                            </state>
 
+                            <transition target="../Paused" event="Simulation.Finished">
 
+                                <raise event="Simulation.Finished" port="user_output"/>
 
+                                <raise event="State" port="user_output">
 
+                                    <parameter expr="self.clock / 1000.0" />
 
+                                    <!--parameter expr="self.state" /-->
 
+                                </raise>
 
+                            </transition>
 
+                            <transition target="../Paused" event="Breakpoint.Triggered">
 
+                                <raise event="Breakpoint.Triggered" port="user_output">
 
+                                    <parameter expr="self.triggered_bp" />
 
+                                </raise>
 
+                                <raise event="State" port="user_output">
 
+                                    <parameter expr="self.clock / 1000.0" />
 
+                                    <!--parameter expr="self.state" /-->
 
+                                </raise>
 
                             </transition>
 
                         </state>
 
-                        <state id="Realtime">
 
-                            <transition target="../Paused" event="Simulation.Finished" />
 
-                            <transition target="../Paused" event="pause" port="user_input">
 
-                                <raise event="Simulation.Pause" />
 
+                        <state id="WaitingForPaused">
 
+                            <transition target="../Paused" event="Simulation.Paused">
 
+                                <raise event="Simulation.Paused" port="user_output" />
 
+                                <raise event="State" port="user_output">
 
+                                    <parameter expr="self.clock / 1000.0" />
 
+                                    <!--parameter expr="self.state" /-->
 
+                                </raise>
 
                             </transition>
 
                         </state>
 
                     </state>
 
@@ -361,13 +407,14 @@
 
                     </state>
 
                     <state id="Initializer" initial="Waiting">
 
                         <state id="Waiting">
 
-                            <transition target="../InitializingSimulation" cond="(INSTATE('../../ModeSelector/SmallStep') or INSTATE('../../ModeSelector/BigStep') or INSTATE('../../ModeSelector/Continuous') or (INSTATE('../../ModeSelector/Realtime'))) and INSTATE('../../SimulationState/Uninitialized')">
 
+                            <!-- always initialize an uninitialized simulation -->
 
+                            <transition target="../InitializingSimulation" cond="INSTATE('../../SimulationState/Uninitialized')">
 
                                 <raise event="Simulation.Reset" />
 
                             </transition>
 
-                            <transition target="../InitializingBigStep" cond="(INSTATE('../../ModeSelector/SmallStep') or INSTATE('../../ModeSelector/BigStep')) and INSTATE('../../SimulationState/Initialized') and INSTATE('../../BigStepState/Uninitialized')">
 
+                            <transition target="../InitializingBigStep" cond="(INSTATE('../../ModeSelector/Running/SmallStep') or INSTATE('../../ModeSelector/Running/BigStep')) and INSTATE('../../SimulationState/Initialized') and INSTATE('../../BigStepState/Uninitialized')">
 
                                 <raise event="BigStep.Reset" />
 
                             </transition>
 
-                            <transition target="../InitializingSmallStep" cond="INSTATE('../../ModeSelector/SmallStep') and INSTATE('../../BigStepState/Initialized') and INSTATE('../../SmallStepState/Uninitialized')">
 
+                            <transition target="../InitializingSmallStep" cond="INSTATE('../../ModeSelector/Running/SmallStep') and INSTATE('../../BigStepState/Initialized') and INSTATE('../../SmallStepState/Uninitialized')">
 
                                 <raise event="SmallStep.Reset" />
 
                             </transition>
 
                         </state>
 
@@ -386,16 +433,16 @@
 
                             <transition target="../Paused" after="self.sccd_yield()" />
 
                         </state>
 
                         <state id="Paused">
 
-                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/SmallStep') and INSTATE('../../SmallStepState/Initialized')">
 
+                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Running/SmallStep') and INSTATE('../../SmallStepState/Initialized')">
 
                                 <raise event="SmallStep.Execute" />
 
                             </transition>
 
-                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/BigStep') and INSTATE('../../BigStepState/Initialized')">
 
+                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Running/BigStep') and INSTATE('../../BigStepState/Initialized')">
 
                                 <raise event="BigStep.Execute" />
 
                             </transition>
 
-                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Continuous') and INSTATE('../../SimulationState/Initialized')">
 
+                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Running/Continuous') and INSTATE('../../SimulationState/Initialized')">
 
                                 <raise event="Simulation.Execute" />
 
                             </transition>
 
-                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Realtime') and INSTATE('../../SimulationState/Initialized')">
 
+                            <transition target="../Executing" cond="INSTATE('../../ModeSelector/Running/Realtime') and INSTATE('../../SimulationState/Initialized')">
 
                                 <raise event="Simulation.ExecuteRealtime">
 
                                     <parameter expr="self.realtime_scale" />
 
                                 </raise>
 
@@ -403,7 +450,60 @@
 
                         </state>
 
                         <state id="Executing">
 
                             <transition target="../Paused" cond="INSTATE('../../ModeSelector/Paused')" />
 
-                            <transition target="../PrePaused" event="Simulation.Finished" cond="INSTATE('../../ModeSelector/Continuous') or INSTATE('../../ModeSelector/Realtime')" />
 
+                            <transition target="../PrePaused" event="Simulation.Finished" cond="INSTATE('../../ModeSelector/Running/Continuous') or INSTATE('../../ModeSelector/Running/Realtime')" />
 
+                        </state>
 
+                    </state>
 
+                    <state id="GodEventManager" initial="Listening">
 
+                        <state id="Listening">
 
+                            <transition target="." event="god_event" port="user_input" cond="INSTATE('../../ModeSelector/Paused')">
 
+                                <parameter name="block_name" />
 
+                                <parameter name="new_val" />
 
+                                <script>
 
+                                    result = self.godEvent(block_name, new_val)
 
+                                </script>
 
+                                <raise event="god_event_result" port="user_output">
 
+                                    <parameter expr="result" />
 
+                                </raise>
 
+                            </transition>
 
+                        </state>
 
+                    </state>
 
+                    <state id="BreakpointManager" initial="Listening">
 
+                        <state id="Listening">
 
+                            <transition target="." event="add_breakpoint" port="user_input">
 
+                                <parameter name="name"/>
 
+                                <parameter name="function"/>
 
+                                <parameter name="enabled"/>
 
+                                <parameter name="disable_on_trigger"/>
 
+                                <script>
 
+                                    result = self.addBreakpoint(name, function, bool(enabled), bool(disable_on_trigger))
 
+                                </script>
 
+                                <raise event="add_breakpoint_result" port="user_output">
 
+                                    <parameter expr="result" />
 
+                                </raise>
 
+                            </transition>
 
+                            <transition target="." event="del_breakpoint" port="user_input">
 
+                                <parameter name="name"/>
 
+                                <script>
 
+                                    result = self.delBreakpoint(name)
 
+                                </script>
 
+                                <raise event="del_breakpoint_result" port="user_output">
 
+                                    <parameter expr="result" />
 
+                                </raise>
 
+                            </transition>
 
+                            <transition target="." event="toggle_breakpoint" port="user_input">
 
+                                <parameter name="name"/>
 
+                                <script>
 
+                                    result = self.toggleBreakpoint(name)
 
+                                </script>
 
+                                <raise event="toggle_breakpoint_result" port="user_output">
 
+                                    <parameter expr="result" />
 
+                                </raise>
 
+                            </transition>
 
+                            <transition target="." event="list_breakpoints" port="user_input">
 
+                                <raise event="list_breakpoints_result" port="user_output">
 
+                                    <parameter expr="[bp.name for bp in self.breakpoints]" />
 
+                                </raise>
 
+                            </transition>
 
                         </state>
 
                     </state>
 
                 </parallel>
 
@@ -422,12 +522,19 @@
 
                                     self.realtime_start_time = accurate_time.time() - (self.clock / self.realtime_scale)
 
                                 </script>
 
                             </transition>
 
+                            <state id="BreakpointTriggered" />
 
                         </state>
 
                         <state id="Continuous">
 
                             <transition target="../Paused" event="Simulation.Pause" />
 
+                            <transition target="../Paused/BreakpointTriggered" cond="self.breakpointTriggers(False)">
 
+                                <raise event="Breakpoint.Triggered" />
 
+                            </transition>
 
                         </state>
 
                         <state id="Realtime">
 
                             <transition target="../Paused" event="Simulation.Pause" />
 
+                            <transition target="../Paused/BreakpointTriggered" cond="self.breakpointTriggers(True)">
 
+                                <raise event="Breakpoint.Triggered" />
 
+                            </transition>
 
                         </state>
 
                     </state>
 
                     <state id="SimulationFlow" initial="Stopped">
 
@@ -457,18 +564,13 @@
 
                             </transition>
 
                         </state>
 
                         <state id="Waiting">
 
-                            <transition target="../CheckTermination" cond="INSTATE('../../SimulationState/Continuous') or INSTATE('../../SimulationState/Realtime')" />
 
-                            <!-- in case a big step triggers the end condition of a big step -->
 
-                            <transition target="../Stopped" cond="self.endConditionSimulation()">
 
-                                <script>
 
-                                    print 'simulation executed'
 
-                                    self.finalizeSimulation()
 
-                                </script>
 
-                                <raise event="Simulation.Finished" />
 
-                            </transition>
 
+                            <transition target="../CheckTermination" />
 
                         </state>
 
                         <state id="SettleBeforeCheckTermination">
 
                             <transition target="../CheckTermination" after="self.sccd_yield()" />
 
+                            <transition target="../CheckTermination" cond="INSTATE('../../SimulationState/Paused')">
 
+                                <raise event="Simulation.Paused" />
 
+                            </transition>
 
                         </state>
 
                         <state id="CheckTermination">
 
                             <transition target="../InitializingBigStep" cond="INSTATE('../../SimulationState/Continuous') and not self.endConditionSimulation()">
 
@@ -491,6 +593,9 @@
 
                                     self.syncSimulatedTime()
 
                                 </script>
 
                             </transition>
 
+                            <transition target="../CheckTermination" cond="INSTATE('../../SimulationState/Paused')">
 
+                                <raise event="Simulation.Paused" />
 
+                            </transition>
 
                             <!-- We execute a step when the wait time is smaller than the smallest possible delay. -->
 
                             <transition target="../InitializingBigStep" cond="self.waitTime() / 1000.0 &lt;= self.sccd_yield()">
 
                                 <raise event="BigStep.Reset" />

+ 300 - 142
debugging_fsa_cbd_composition/cbdsimulator/target.py
Wyświetl plik 

@@ -1,7 +1,7 @@
 
 """
 
 Generated by Statechart compiler by Glenn De Jonghe, Joeri Exelmans, Simon Van Mierlo, and Yentl Van Tendeloo (for the inspiration)
 
 
-Date:   Thu Oct 27 18:22:53 2016
 
+Date:   Thu Oct 27 20:37:34 2016
 
 
 Model author: Sadaf Mustafiz and Claudio Gomes and Simon Van Mierlo
 
 Model name:   CBDSimulator
 
@@ -253,6 +253,8 @@ class CBDSimulator(RuntimeClassBase):
 
     
     # user defined method
 
     def godEvent(self, block_name, new_val):
 
+        if not self.simulationInitialized():
 
+            return -1
 
         if block_name not in self.state:
 
             return -1
 
         for b in self.model.getBlocks():
 
@@ -280,193 +282,214 @@ class CBDSimulator(RuntimeClassBase):
 
         # state /Main/SimulationCoordinator/ModeSelector/Paused
 
         self.states["/Main/SimulationCoordinator/ModeSelector/Paused"] = State(4, "/Main/SimulationCoordinator/ModeSelector/Paused", self)
 
         
-        # state /Main/SimulationCoordinator/ModeSelector/SmallStep
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/SmallStep"] = State(5, "/Main/SimulationCoordinator/ModeSelector/SmallStep", self)
 
+        # state /Main/SimulationCoordinator/ModeSelector/Running
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"] = State(5, "/Main/SimulationCoordinator/ModeSelector/Running", self)
 
+        
+        # state /Main/SimulationCoordinator/ModeSelector/Running/Continuous
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"] = State(6, "/Main/SimulationCoordinator/ModeSelector/Running/Continuous", self)
 
+        
+        # state /Main/SimulationCoordinator/ModeSelector/Running/Realtime
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"] = State(7, "/Main/SimulationCoordinator/ModeSelector/Running/Realtime", self)
 
         
-        # state /Main/SimulationCoordinator/ModeSelector/BigStep
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/BigStep"] = State(6, "/Main/SimulationCoordinator/ModeSelector/BigStep", self)
 
+        # state /Main/SimulationCoordinator/ModeSelector/Running/BigStep
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"] = State(8, "/Main/SimulationCoordinator/ModeSelector/Running/BigStep", self)
 
         
-        # state /Main/SimulationCoordinator/ModeSelector/Continuous
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"] = State(7, "/Main/SimulationCoordinator/ModeSelector/Continuous", self)
 
+        # state /Main/SimulationCoordinator/ModeSelector/Running/SmallStep
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"] = State(9, "/Main/SimulationCoordinator/ModeSelector/Running/SmallStep", self)
 
         
-        # state /Main/SimulationCoordinator/ModeSelector/Realtime
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"] = State(8, "/Main/SimulationCoordinator/ModeSelector/Realtime", self)
 
+        # state /Main/SimulationCoordinator/ModeSelector/WaitingForPaused
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"] = State(10, "/Main/SimulationCoordinator/ModeSelector/WaitingForPaused", self)
 
         
         # state /Main/SimulationCoordinator/SmallStepState
 
-        self.states["/Main/SimulationCoordinator/SmallStepState"] = State(9, "/Main/SimulationCoordinator/SmallStepState", self)
 
+        self.states["/Main/SimulationCoordinator/SmallStepState"] = State(11, "/Main/SimulationCoordinator/SmallStepState", self)
 
         
         # state /Main/SimulationCoordinator/SmallStepState/Uninitialized
 
-        self.states["/Main/SimulationCoordinator/SmallStepState/Uninitialized"] = State(10, "/Main/SimulationCoordinator/SmallStepState/Uninitialized", self)
 
+        self.states["/Main/SimulationCoordinator/SmallStepState/Uninitialized"] = State(12, "/Main/SimulationCoordinator/SmallStepState/Uninitialized", self)
 
         
         # state /Main/SimulationCoordinator/SmallStepState/Initialized
 
-        self.states["/Main/SimulationCoordinator/SmallStepState/Initialized"] = State(11, "/Main/SimulationCoordinator/SmallStepState/Initialized", self)
 
+        self.states["/Main/SimulationCoordinator/SmallStepState/Initialized"] = State(13, "/Main/SimulationCoordinator/SmallStepState/Initialized", self)
 
         
         # state /Main/SimulationCoordinator/BigStepState
 
-        self.states["/Main/SimulationCoordinator/BigStepState"] = State(12, "/Main/SimulationCoordinator/BigStepState", self)
 
+        self.states["/Main/SimulationCoordinator/BigStepState"] = State(14, "/Main/SimulationCoordinator/BigStepState", self)
 
         
         # state /Main/SimulationCoordinator/BigStepState/Uninitialized
 
-        self.states["/Main/SimulationCoordinator/BigStepState/Uninitialized"] = State(13, "/Main/SimulationCoordinator/BigStepState/Uninitialized", self)
 
+        self.states["/Main/SimulationCoordinator/BigStepState/Uninitialized"] = State(15, "/Main/SimulationCoordinator/BigStepState/Uninitialized", self)
 
         
         # state /Main/SimulationCoordinator/BigStepState/Initialized
 
-        self.states["/Main/SimulationCoordinator/BigStepState/Initialized"] = State(14, "/Main/SimulationCoordinator/BigStepState/Initialized", self)
 
+        self.states["/Main/SimulationCoordinator/BigStepState/Initialized"] = State(16, "/Main/SimulationCoordinator/BigStepState/Initialized", self)
 
         
         # state /Main/SimulationCoordinator/SimulationState
 
-        self.states["/Main/SimulationCoordinator/SimulationState"] = State(15, "/Main/SimulationCoordinator/SimulationState", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationState"] = State(17, "/Main/SimulationCoordinator/SimulationState", self)
 
         
         # state /Main/SimulationCoordinator/SimulationState/Uninitialized
 
-        self.states["/Main/SimulationCoordinator/SimulationState/Uninitialized"] = State(16, "/Main/SimulationCoordinator/SimulationState/Uninitialized", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationState/Uninitialized"] = State(18, "/Main/SimulationCoordinator/SimulationState/Uninitialized", self)
 
         
         # state /Main/SimulationCoordinator/SimulationState/Initialized
 
-        self.states["/Main/SimulationCoordinator/SimulationState/Initialized"] = State(17, "/Main/SimulationCoordinator/SimulationState/Initialized", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationState/Initialized"] = State(19, "/Main/SimulationCoordinator/SimulationState/Initialized", self)
 
         
         # state /Main/SimulationCoordinator/Initializer
 
-        self.states["/Main/SimulationCoordinator/Initializer"] = State(18, "/Main/SimulationCoordinator/Initializer", self)
 
+        self.states["/Main/SimulationCoordinator/Initializer"] = State(20, "/Main/SimulationCoordinator/Initializer", self)
 
         
         # state /Main/SimulationCoordinator/Initializer/Waiting
 
-        self.states["/Main/SimulationCoordinator/Initializer/Waiting"] = State(19, "/Main/SimulationCoordinator/Initializer/Waiting", self)
 
+        self.states["/Main/SimulationCoordinator/Initializer/Waiting"] = State(21, "/Main/SimulationCoordinator/Initializer/Waiting", self)
 
         
         # state /Main/SimulationCoordinator/Initializer/InitializingSimulation
 
-        self.states["/Main/SimulationCoordinator/Initializer/InitializingSimulation"] = State(20, "/Main/SimulationCoordinator/Initializer/InitializingSimulation", self)
 
+        self.states["/Main/SimulationCoordinator/Initializer/InitializingSimulation"] = State(22, "/Main/SimulationCoordinator/Initializer/InitializingSimulation", self)
 
         
         # state /Main/SimulationCoordinator/Initializer/InitializingBigStep
 
-        self.states["/Main/SimulationCoordinator/Initializer/InitializingBigStep"] = State(21, "/Main/SimulationCoordinator/Initializer/InitializingBigStep", self)
 
+        self.states["/Main/SimulationCoordinator/Initializer/InitializingBigStep"] = State(23, "/Main/SimulationCoordinator/Initializer/InitializingBigStep", self)
 
         
         # state /Main/SimulationCoordinator/Initializer/InitializingSmallStep
 
-        self.states["/Main/SimulationCoordinator/Initializer/InitializingSmallStep"] = State(22, "/Main/SimulationCoordinator/Initializer/InitializingSmallStep", self)
 
+        self.states["/Main/SimulationCoordinator/Initializer/InitializingSmallStep"] = State(24, "/Main/SimulationCoordinator/Initializer/InitializingSmallStep", self)
 
         
         # state /Main/SimulationCoordinator/SimulationFlow
 
-        self.states["/Main/SimulationCoordinator/SimulationFlow"] = State(23, "/Main/SimulationCoordinator/SimulationFlow", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationFlow"] = State(25, "/Main/SimulationCoordinator/SimulationFlow", self)
 
         
         # state /Main/SimulationCoordinator/SimulationFlow/PrePaused
 
-        self.states["/Main/SimulationCoordinator/SimulationFlow/PrePaused"] = State(24, "/Main/SimulationCoordinator/SimulationFlow/PrePaused", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationFlow/PrePaused"] = State(26, "/Main/SimulationCoordinator/SimulationFlow/PrePaused", self)
 
         self.states["/Main/SimulationCoordinator/SimulationFlow/PrePaused"].setEnter(self._Main_SimulationCoordinator_SimulationFlow_PrePaused_enter)
 
         self.states["/Main/SimulationCoordinator/SimulationFlow/PrePaused"].setExit(self._Main_SimulationCoordinator_SimulationFlow_PrePaused_exit)
 
         
         # state /Main/SimulationCoordinator/SimulationFlow/Paused
 
-        self.states["/Main/SimulationCoordinator/SimulationFlow/Paused"] = State(25, "/Main/SimulationCoordinator/SimulationFlow/Paused", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationFlow/Paused"] = State(27, "/Main/SimulationCoordinator/SimulationFlow/Paused", self)
 
         
         # state /Main/SimulationCoordinator/SimulationFlow/Executing
 
-        self.states["/Main/SimulationCoordinator/SimulationFlow/Executing"] = State(26, "/Main/SimulationCoordinator/SimulationFlow/Executing", self)
 
+        self.states["/Main/SimulationCoordinator/SimulationFlow/Executing"] = State(28, "/Main/SimulationCoordinator/SimulationFlow/Executing", self)
 
+        
+        # state /Main/SimulationCoordinator/GodEventManager
 
+        self.states["/Main/SimulationCoordinator/GodEventManager"] = State(29, "/Main/SimulationCoordinator/GodEventManager", self)
 
+        
+        # state /Main/SimulationCoordinator/GodEventManager/Listening
 
+        self.states["/Main/SimulationCoordinator/GodEventManager/Listening"] = State(30, "/Main/SimulationCoordinator/GodEventManager/Listening", self)
 
+        
+        # state /Main/SimulationCoordinator/BreakpointManager
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager"] = State(31, "/Main/SimulationCoordinator/BreakpointManager", self)
 
+        
+        # state /Main/SimulationCoordinator/BreakpointManager/Listening
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"] = State(32, "/Main/SimulationCoordinator/BreakpointManager/Listening", self)
 
         
         # state /Main/ExecuteSimulation
 
-        self.states["/Main/ExecuteSimulation"] = ParallelState(27, "/Main/ExecuteSimulation", self)
 
+        self.states["/Main/ExecuteSimulation"] = ParallelState(33, "/Main/ExecuteSimulation", self)
 
         
         # state /Main/ExecuteSimulation/SimulationState
 
-        self.states["/Main/ExecuteSimulation/SimulationState"] = State(28, "/Main/ExecuteSimulation/SimulationState", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationState"] = State(34, "/Main/ExecuteSimulation/SimulationState", self)
 
         
         # state /Main/ExecuteSimulation/SimulationState/Paused
 
-        self.states["/Main/ExecuteSimulation/SimulationState/Paused"] = State(29, "/Main/ExecuteSimulation/SimulationState/Paused", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused"] = State(35, "/Main/ExecuteSimulation/SimulationState/Paused", self)
 
+        
+        # state /Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered"] = State(36, "/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered", self)
 
         
         # state /Main/ExecuteSimulation/SimulationState/Continuous
 
-        self.states["/Main/ExecuteSimulation/SimulationState/Continuous"] = State(30, "/Main/ExecuteSimulation/SimulationState/Continuous", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Continuous"] = State(37, "/Main/ExecuteSimulation/SimulationState/Continuous", self)
 
         
         # state /Main/ExecuteSimulation/SimulationState/Realtime
 
-        self.states["/Main/ExecuteSimulation/SimulationState/Realtime"] = State(31, "/Main/ExecuteSimulation/SimulationState/Realtime", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Realtime"] = State(38, "/Main/ExecuteSimulation/SimulationState/Realtime", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow"] = State(32, "/Main/ExecuteSimulation/SimulationFlow", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow"] = State(39, "/Main/ExecuteSimulation/SimulationFlow", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/Stopped
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"] = State(33, "/Main/ExecuteSimulation/SimulationFlow/Stopped", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"] = State(40, "/Main/ExecuteSimulation/SimulationFlow/Stopped", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/Started
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Started"] = State(34, "/Main/ExecuteSimulation/SimulationFlow/Started", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/Started"] = State(41, "/Main/ExecuteSimulation/SimulationFlow/Started", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/Initialized
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Initialized"] = State(35, "/Main/ExecuteSimulation/SimulationFlow/Initialized", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/Initialized"] = State(42, "/Main/ExecuteSimulation/SimulationFlow/Initialized", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/InitializeDebugger
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/InitializeDebugger"] = State(36, "/Main/ExecuteSimulation/SimulationFlow/InitializeDebugger", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/InitializeDebugger"] = State(43, "/Main/ExecuteSimulation/SimulationFlow/InitializeDebugger", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/Waiting
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"] = State(37, "/Main/ExecuteSimulation/SimulationFlow/Waiting", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"] = State(44, "/Main/ExecuteSimulation/SimulationFlow/Waiting", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"] = State(38, "/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"] = State(45, "/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination", self)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"].setEnter(self._Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_enter)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"].setExit(self._Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_exit)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/CheckTermination
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"] = State(39, "/Main/ExecuteSimulation/SimulationFlow/CheckTermination", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"] = State(46, "/Main/ExecuteSimulation/SimulationFlow/CheckTermination", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/WaitingRealtime
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"] = State(40, "/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"] = State(47, "/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime", self)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"].setEnter(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_enter)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"].setExit(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_exit)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/InitializingBigStep
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"] = State(41, "/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"] = State(48, "/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep", self)
 
         
         # state /Main/ExecuteSimulation/SimulationFlow/Executing
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Executing"] = State(42, "/Main/ExecuteSimulation/SimulationFlow/Executing", self)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/Executing"] = State(49, "/Main/ExecuteSimulation/SimulationFlow/Executing", self)
 
         
         # state /Main/ExecuteBigStep
 
-        self.states["/Main/ExecuteBigStep"] = State(43, "/Main/ExecuteBigStep", self)
 
+        self.states["/Main/ExecuteBigStep"] = State(50, "/Main/ExecuteBigStep", self)
 
         
         # state /Main/ExecuteBigStep/Stopped
 
-        self.states["/Main/ExecuteBigStep/Stopped"] = State(44, "/Main/ExecuteBigStep/Stopped", self)
 
+        self.states["/Main/ExecuteBigStep/Stopped"] = State(51, "/Main/ExecuteBigStep/Stopped", self)
 
         
         # state /Main/ExecuteBigStep/Started
 
-        self.states["/Main/ExecuteBigStep/Started"] = State(45, "/Main/ExecuteBigStep/Started", self)
 
+        self.states["/Main/ExecuteBigStep/Started"] = State(52, "/Main/ExecuteBigStep/Started", self)
 
         
         # state /Main/ExecuteBigStep/Initialized
 
-        self.states["/Main/ExecuteBigStep/Initialized"] = State(46, "/Main/ExecuteBigStep/Initialized", self)
 
+        self.states["/Main/ExecuteBigStep/Initialized"] = State(53, "/Main/ExecuteBigStep/Initialized", self)
 
         
         # state /Main/ExecuteBigStep/InitializeDebugger
 
-        self.states["/Main/ExecuteBigStep/InitializeDebugger"] = State(47, "/Main/ExecuteBigStep/InitializeDebugger", self)
 
+        self.states["/Main/ExecuteBigStep/InitializeDebugger"] = State(54, "/Main/ExecuteBigStep/InitializeDebugger", self)
 
         
         # state /Main/ExecuteBigStep/Waiting
 
-        self.states["/Main/ExecuteBigStep/Waiting"] = State(48, "/Main/ExecuteBigStep/Waiting", self)
 
+        self.states["/Main/ExecuteBigStep/Waiting"] = State(55, "/Main/ExecuteBigStep/Waiting", self)
 
         
         # state /Main/ExecuteBigStep/SettleBeforeCheckTermination
 
-        self.states["/Main/ExecuteBigStep/SettleBeforeCheckTermination"] = State(49, "/Main/ExecuteBigStep/SettleBeforeCheckTermination", self)
 
+        self.states["/Main/ExecuteBigStep/SettleBeforeCheckTermination"] = State(56, "/Main/ExecuteBigStep/SettleBeforeCheckTermination", self)
 
         self.states["/Main/ExecuteBigStep/SettleBeforeCheckTermination"].setEnter(self._Main_ExecuteBigStep_SettleBeforeCheckTermination_enter)
 
         self.states["/Main/ExecuteBigStep/SettleBeforeCheckTermination"].setExit(self._Main_ExecuteBigStep_SettleBeforeCheckTermination_exit)
 
         
         # state /Main/ExecuteBigStep/CheckTermination
 
-        self.states["/Main/ExecuteBigStep/CheckTermination"] = State(50, "/Main/ExecuteBigStep/CheckTermination", self)
 
+        self.states["/Main/ExecuteBigStep/CheckTermination"] = State(57, "/Main/ExecuteBigStep/CheckTermination", self)
 
         
         # state /Main/ExecuteBigStep/InitializingSmallStep
 
-        self.states["/Main/ExecuteBigStep/InitializingSmallStep"] = State(51, "/Main/ExecuteBigStep/InitializingSmallStep", self)
 
+        self.states["/Main/ExecuteBigStep/InitializingSmallStep"] = State(58, "/Main/ExecuteBigStep/InitializingSmallStep", self)
 
         
         # state /Main/ExecuteBigStep/Executing
 
-        self.states["/Main/ExecuteBigStep/Executing"] = State(52, "/Main/ExecuteBigStep/Executing", self)
 
+        self.states["/Main/ExecuteBigStep/Executing"] = State(59, "/Main/ExecuteBigStep/Executing", self)
 
         
         # state /Main/ExecuteSmallStep
 
-        self.states["/Main/ExecuteSmallStep"] = State(53, "/Main/ExecuteSmallStep", self)
 
+        self.states["/Main/ExecuteSmallStep"] = State(60, "/Main/ExecuteSmallStep", self)
 
         
         # state /Main/ExecuteSmallStep/Stopped
 
-        self.states["/Main/ExecuteSmallStep/Stopped"] = State(54, "/Main/ExecuteSmallStep/Stopped", self)
 
+        self.states["/Main/ExecuteSmallStep/Stopped"] = State(61, "/Main/ExecuteSmallStep/Stopped", self)
 
         
         # state /Main/ExecuteSmallStep/Started
 
-        self.states["/Main/ExecuteSmallStep/Started"] = State(55, "/Main/ExecuteSmallStep/Started", self)
 
+        self.states["/Main/ExecuteSmallStep/Started"] = State(62, "/Main/ExecuteSmallStep/Started", self)
 
         
         # state /Main/ExecuteSmallStep/Initialized
 
-        self.states["/Main/ExecuteSmallStep/Initialized"] = State(56, "/Main/ExecuteSmallStep/Initialized", self)
 
+        self.states["/Main/ExecuteSmallStep/Initialized"] = State(63, "/Main/ExecuteSmallStep/Initialized", self)
 
         
         # state /Main/ExecuteSmallStep/InitializeDebugger
 
-        self.states["/Main/ExecuteSmallStep/InitializeDebugger"] = State(57, "/Main/ExecuteSmallStep/InitializeDebugger", self)
 
+        self.states["/Main/ExecuteSmallStep/InitializeDebugger"] = State(64, "/Main/ExecuteSmallStep/InitializeDebugger", self)
 
         
         # state /Main/ExecuteSmallStep/Waiting
 
-        self.states["/Main/ExecuteSmallStep/Waiting"] = State(58, "/Main/ExecuteSmallStep/Waiting", self)
 
+        self.states["/Main/ExecuteSmallStep/Waiting"] = State(65, "/Main/ExecuteSmallStep/Waiting", self)
 
         
         # state /Main/ExecuteSmallStep/SettleBeforeCheckTermination
 
-        self.states["/Main/ExecuteSmallStep/SettleBeforeCheckTermination"] = State(59, "/Main/ExecuteSmallStep/SettleBeforeCheckTermination", self)
 
+        self.states["/Main/ExecuteSmallStep/SettleBeforeCheckTermination"] = State(66, "/Main/ExecuteSmallStep/SettleBeforeCheckTermination", self)
 
         self.states["/Main/ExecuteSmallStep/SettleBeforeCheckTermination"].setEnter(self._Main_ExecuteSmallStep_SettleBeforeCheckTermination_enter)
 
         self.states["/Main/ExecuteSmallStep/SettleBeforeCheckTermination"].setExit(self._Main_ExecuteSmallStep_SettleBeforeCheckTermination_exit)
 
         
         # state /Main/ExecuteSmallStep/CheckTermination
 
-        self.states["/Main/ExecuteSmallStep/CheckTermination"] = State(60, "/Main/ExecuteSmallStep/CheckTermination", self)
 
+        self.states["/Main/ExecuteSmallStep/CheckTermination"] = State(67, "/Main/ExecuteSmallStep/CheckTermination", self)
 
         
         # state /Main/ExecuteSmallStep/Executing
 
-        self.states["/Main/ExecuteSmallStep/Executing"] = State(61, "/Main/ExecuteSmallStep/Executing", self)
 
+        self.states["/Main/ExecuteSmallStep/Executing"] = State(68, "/Main/ExecuteSmallStep/Executing", self)
 
         self.states["/Main/ExecuteSmallStep/Executing"].setEnter(self._Main_ExecuteSmallStep_Executing_enter)
 
         
         # state /Main/ExecuteBlock
 
-        self.states["/Main/ExecuteBlock"] = State(62, "/Main/ExecuteBlock", self)
 
+        self.states["/Main/ExecuteBlock"] = State(69, "/Main/ExecuteBlock", self)
 
         
         # state /Main/ExecuteBlock/Waiting
 
-        self.states["/Main/ExecuteBlock/Waiting"] = State(63, "/Main/ExecuteBlock/Waiting", self)
 
+        self.states["/Main/ExecuteBlock/Waiting"] = State(70, "/Main/ExecuteBlock/Waiting", self)
 
         
         # add children
 
         self.states[""].addChild(self.states["/Main"])
 
@@ -481,11 +504,15 @@ class CBDSimulator(RuntimeClassBase):
 
         self.states["/Main/SimulationCoordinator"].addChild(self.states["/Main/SimulationCoordinator/SimulationState"])
 
         self.states["/Main/SimulationCoordinator"].addChild(self.states["/Main/SimulationCoordinator/Initializer"])
 
         self.states["/Main/SimulationCoordinator"].addChild(self.states["/Main/SimulationCoordinator/SimulationFlow"])
 
+        self.states["/Main/SimulationCoordinator"].addChild(self.states["/Main/SimulationCoordinator/GodEventManager"])
 
+        self.states["/Main/SimulationCoordinator"].addChild(self.states["/Main/SimulationCoordinator/BreakpointManager"])
 
         self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Paused"])
 
-        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/SmallStep"])
 
-        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/BigStep"])
 
-        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"])
 
-        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Running"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"])
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addChild(self.states["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"])
 
         self.states["/Main/SimulationCoordinator/SmallStepState"].addChild(self.states["/Main/SimulationCoordinator/SmallStepState/Uninitialized"])
 
         self.states["/Main/SimulationCoordinator/SmallStepState"].addChild(self.states["/Main/SimulationCoordinator/SmallStepState/Initialized"])
 
         self.states["/Main/SimulationCoordinator/BigStepState"].addChild(self.states["/Main/SimulationCoordinator/BigStepState/Uninitialized"])
 
@@ -499,11 +526,14 @@ class CBDSimulator(RuntimeClassBase):
 
         self.states["/Main/SimulationCoordinator/SimulationFlow"].addChild(self.states["/Main/SimulationCoordinator/SimulationFlow/PrePaused"])
 
         self.states["/Main/SimulationCoordinator/SimulationFlow"].addChild(self.states["/Main/SimulationCoordinator/SimulationFlow/Paused"])
 
         self.states["/Main/SimulationCoordinator/SimulationFlow"].addChild(self.states["/Main/SimulationCoordinator/SimulationFlow/Executing"])
 
+        self.states["/Main/SimulationCoordinator/GodEventManager"].addChild(self.states["/Main/SimulationCoordinator/GodEventManager/Listening"])
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager"].addChild(self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"])
 
         self.states["/Main/ExecuteSimulation"].addChild(self.states["/Main/ExecuteSimulation/SimulationState"])
 
         self.states["/Main/ExecuteSimulation"].addChild(self.states["/Main/ExecuteSimulation/SimulationFlow"])
 
         self.states["/Main/ExecuteSimulation/SimulationState"].addChild(self.states["/Main/ExecuteSimulation/SimulationState/Paused"])
 
         self.states["/Main/ExecuteSimulation/SimulationState"].addChild(self.states["/Main/ExecuteSimulation/SimulationState/Continuous"])
 
         self.states["/Main/ExecuteSimulation/SimulationState"].addChild(self.states["/Main/ExecuteSimulation/SimulationState/Realtime"])
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].addChild(self.states["/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered"])
 
         self.states["/Main/ExecuteSimulation/SimulationFlow"].addChild(self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"])
 
         self.states["/Main/ExecuteSimulation/SimulationFlow"].addChild(self.states["/Main/ExecuteSimulation/SimulationFlow/Started"])
 
         self.states["/Main/ExecuteSimulation/SimulationFlow"].addChild(self.states["/Main/ExecuteSimulation/SimulationFlow/Initialized"])
 
@@ -535,59 +565,69 @@ class CBDSimulator(RuntimeClassBase):
 
         self.states[""].fixTree()
 
         self.states[""].default_state = self.states["/Main"]
 
         self.states["/Main/SimulationCoordinator/ModeSelector"].default_state = self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].default_state = self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"]
 
         self.states["/Main/SimulationCoordinator/SmallStepState"].default_state = self.states["/Main/SimulationCoordinator/SmallStepState/Uninitialized"]
 
         self.states["/Main/SimulationCoordinator/BigStepState"].default_state = self.states["/Main/SimulationCoordinator/BigStepState/Uninitialized"]
 
         self.states["/Main/SimulationCoordinator/SimulationState"].default_state = self.states["/Main/SimulationCoordinator/SimulationState/Uninitialized"]
 
         self.states["/Main/SimulationCoordinator/Initializer"].default_state = self.states["/Main/SimulationCoordinator/Initializer/Waiting"]
 
         self.states["/Main/SimulationCoordinator/SimulationFlow"].default_state = self.states["/Main/SimulationCoordinator/SimulationFlow/Paused"]
 
+        self.states["/Main/SimulationCoordinator/GodEventManager"].default_state = self.states["/Main/SimulationCoordinator/GodEventManager/Listening"]
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager"].default_state = self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"]
 
         self.states["/Main/ExecuteSimulation/SimulationState"].default_state = self.states["/Main/ExecuteSimulation/SimulationState/Paused"]
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].default_state = self.states["/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered"]
 
         self.states["/Main/ExecuteSimulation/SimulationFlow"].default_state = self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"]
 
         self.states["/Main/ExecuteBigStep"].default_state = self.states["/Main/ExecuteBigStep/Stopped"]
 
         self.states["/Main/ExecuteSmallStep"].default_state = self.states["/Main/ExecuteSmallStep/Stopped"]
 
         self.states["/Main/ExecuteBlock"].default_state = self.states["/Main/ExecuteBlock/Waiting"]
 
         
         # transition /Main/SimulationCoordinator/ModeSelector/Paused
 
-        _Main_SimulationCoordinator_ModeSelector_Paused_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/SmallStep"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Paused_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"]])
 
         _Main_SimulationCoordinator_ModeSelector_Paused_0.setTrigger(Event("small_step", "user_input"))
 
         self.states["/Main/SimulationCoordinator/ModeSelector/Paused"].addTransition(_Main_SimulationCoordinator_ModeSelector_Paused_0)
 
-        _Main_SimulationCoordinator_ModeSelector_Paused_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/BigStep"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Paused_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"]])
 
         _Main_SimulationCoordinator_ModeSelector_Paused_1.setTrigger(Event("big_step", "user_input"))
 
         self.states["/Main/SimulationCoordinator/ModeSelector/Paused"].addTransition(_Main_SimulationCoordinator_ModeSelector_Paused_1)
 
-        _Main_SimulationCoordinator_ModeSelector_Paused_2 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Paused_2 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"]])
 
         _Main_SimulationCoordinator_ModeSelector_Paused_2.setTrigger(Event("continuous", "user_input"))
 
         self.states["/Main/SimulationCoordinator/ModeSelector/Paused"].addTransition(_Main_SimulationCoordinator_ModeSelector_Paused_2)
 
-        _Main_SimulationCoordinator_ModeSelector_Paused_3 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Paused_3 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Paused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"]])
 
         _Main_SimulationCoordinator_ModeSelector_Paused_3.setAction(self._Main_SimulationCoordinator_ModeSelector_Paused_3_exec)
 
         _Main_SimulationCoordinator_ModeSelector_Paused_3.setTrigger(Event("realtime", "user_input"))
 
         self.states["/Main/SimulationCoordinator/ModeSelector/Paused"].addTransition(_Main_SimulationCoordinator_ModeSelector_Paused_3)
 
         
-        # transition /Main/SimulationCoordinator/ModeSelector/SmallStep
 
-        _Main_SimulationCoordinator_ModeSelector_SmallStep_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/SmallStep"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_SmallStep_0.setTrigger(Event("SmallStep.Finished", None))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/SmallStep"].addTransition(_Main_SimulationCoordinator_ModeSelector_SmallStep_0)
 
-        
-        # transition /Main/SimulationCoordinator/ModeSelector/BigStep
 
-        _Main_SimulationCoordinator_ModeSelector_BigStep_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/BigStep"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_BigStep_0.setTrigger(Event("BigStep.Finished", None))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/BigStep"].addTransition(_Main_SimulationCoordinator_ModeSelector_BigStep_0)
 
-        
-        # transition /Main/SimulationCoordinator/ModeSelector/Continuous
 
-        _Main_SimulationCoordinator_ModeSelector_Continuous_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_Continuous_0.setTrigger(Event("Simulation.Finished", None))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"].addTransition(_Main_SimulationCoordinator_ModeSelector_Continuous_0)
 
-        _Main_SimulationCoordinator_ModeSelector_Continuous_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_Continuous_1.setAction(self._Main_SimulationCoordinator_ModeSelector_Continuous_1_exec)
 
-        _Main_SimulationCoordinator_ModeSelector_Continuous_1.setTrigger(Event("pause", "user_input"))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Continuous"].addTransition(_Main_SimulationCoordinator_ModeSelector_Continuous_1)
 
-        
-        # transition /Main/SimulationCoordinator/ModeSelector/Realtime
 
-        _Main_SimulationCoordinator_ModeSelector_Realtime_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_Realtime_0.setTrigger(Event("Simulation.Finished", None))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"].addTransition(_Main_SimulationCoordinator_ModeSelector_Realtime_0)
 
-        _Main_SimulationCoordinator_ModeSelector_Realtime_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
-        _Main_SimulationCoordinator_ModeSelector_Realtime_1.setAction(self._Main_SimulationCoordinator_ModeSelector_Realtime_1_exec)
 
-        _Main_SimulationCoordinator_ModeSelector_Realtime_1.setTrigger(Event("pause", "user_input"))
 
-        self.states["/Main/SimulationCoordinator/ModeSelector/Realtime"].addTransition(_Main_SimulationCoordinator_ModeSelector_Realtime_1)
 
+        # transition /Main/SimulationCoordinator/ModeSelector/Running/Continuous
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Continuous_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"], [self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Continuous_0.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_Continuous_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Continuous_0.setTrigger(Event("pause", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_Continuous_0)
 
+        
+        # transition /Main/SimulationCoordinator/ModeSelector/Running/Realtime
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"], [self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_0.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_Realtime_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_0.setTrigger(Event("pause", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_Realtime_0)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"], [self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_1.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_Realtime_1_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_Realtime_1.setTrigger(Event("BigStep.Finished", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_Realtime_1)
 
+        
+        # transition /Main/SimulationCoordinator/ModeSelector/Running/BigStep
 
+        _Main_SimulationCoordinator_ModeSelector_Running_BigStep_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_BigStep_0.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_BigStep_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_BigStep_0.setTrigger(Event("BigStep.Finished", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_BigStep_0)
 
+        
+        # transition /Main/SimulationCoordinator/ModeSelector/Running/SmallStep
 
+        _Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0.setTrigger(Event("SmallStep.Finished", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0)
 
+        
+        # transition /Main/SimulationCoordinator/ModeSelector/WaitingForPaused
 
+        _Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0.setAction(self._Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0.setTrigger(Event("Simulation.Paused", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/WaitingForPaused"].addTransition(_Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0)
 
         
         # transition /Main/SimulationCoordinator/SmallStepState/Uninitialized
 
         _Main_SimulationCoordinator_SmallStepState_Uninitialized_0 = Transition(self, self.states["/Main/SimulationCoordinator/SmallStepState/Uninitialized"], [self.states["/Main/SimulationCoordinator/SmallStepState/Initialized"]])
 
@@ -688,24 +728,50 @@ class CBDSimulator(RuntimeClassBase):
 
         _Main_SimulationCoordinator_SimulationFlow_Executing_1.setGuard(self._Main_SimulationCoordinator_SimulationFlow_Executing_1_guard)
 
         self.states["/Main/SimulationCoordinator/SimulationFlow/Executing"].addTransition(_Main_SimulationCoordinator_SimulationFlow_Executing_1)
 
         
-        # transition /Main/ExecuteSimulation/SimulationState/Paused
 
-        _Main_ExecuteSimulation_SimulationState_Paused_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Paused"], [self.states["/Main/ExecuteSimulation/SimulationState/Continuous"]])
 
-        _Main_ExecuteSimulation_SimulationState_Paused_0.setTrigger(Event("Simulation.Execute", None))
 
-        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].addTransition(_Main_ExecuteSimulation_SimulationState_Paused_0)
 
-        _Main_ExecuteSimulation_SimulationState_Paused_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Paused"], [self.states["/Main/ExecuteSimulation/SimulationState/Realtime"]])
 
-        _Main_ExecuteSimulation_SimulationState_Paused_1.setAction(self._Main_ExecuteSimulation_SimulationState_Paused_1_exec)
 
-        _Main_ExecuteSimulation_SimulationState_Paused_1.setTrigger(Event("Simulation.ExecuteRealtime", None))
 
-        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].addTransition(_Main_ExecuteSimulation_SimulationState_Paused_1)
 
+        # transition /Main/SimulationCoordinator/GodEventManager/Listening
 
+        _Main_SimulationCoordinator_GodEventManager_Listening_0 = Transition(self, self.states["/Main/SimulationCoordinator/GodEventManager/Listening"], [self.states["/Main/SimulationCoordinator/GodEventManager/Listening"]])
 
+        _Main_SimulationCoordinator_GodEventManager_Listening_0.setAction(self._Main_SimulationCoordinator_GodEventManager_Listening_0_exec)
 
+        _Main_SimulationCoordinator_GodEventManager_Listening_0.setTrigger(Event("god_event", "user_input"))
 
+        _Main_SimulationCoordinator_GodEventManager_Listening_0.setGuard(self._Main_SimulationCoordinator_GodEventManager_Listening_0_guard)
 
+        self.states["/Main/SimulationCoordinator/GodEventManager/Listening"].addTransition(_Main_SimulationCoordinator_GodEventManager_Listening_0)
 
+        
+        # transition /Main/SimulationCoordinator/BreakpointManager/Listening
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_0 = Transition(self, self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"], [self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"]])
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_0.setAction(self._Main_SimulationCoordinator_BreakpointManager_Listening_0_exec)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_0.setTrigger(Event("add_breakpoint", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"].addTransition(_Main_SimulationCoordinator_BreakpointManager_Listening_0)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_1 = Transition(self, self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"], [self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"]])
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_1.setAction(self._Main_SimulationCoordinator_BreakpointManager_Listening_1_exec)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_1.setTrigger(Event("del_breakpoint", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"].addTransition(_Main_SimulationCoordinator_BreakpointManager_Listening_1)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_2 = Transition(self, self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"], [self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"]])
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_2.setAction(self._Main_SimulationCoordinator_BreakpointManager_Listening_2_exec)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_2.setTrigger(Event("toggle_breakpoint", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"].addTransition(_Main_SimulationCoordinator_BreakpointManager_Listening_2)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_3 = Transition(self, self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"], [self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"]])
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_3.setAction(self._Main_SimulationCoordinator_BreakpointManager_Listening_3_exec)
 
+        _Main_SimulationCoordinator_BreakpointManager_Listening_3.setTrigger(Event("list_breakpoints", "user_input"))
 
+        self.states["/Main/SimulationCoordinator/BreakpointManager/Listening"].addTransition(_Main_SimulationCoordinator_BreakpointManager_Listening_3)
 
         
         # transition /Main/ExecuteSimulation/SimulationState/Continuous
 
         _Main_ExecuteSimulation_SimulationState_Continuous_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Continuous"], [self.states["/Main/ExecuteSimulation/SimulationState/Paused"]])
 
         _Main_ExecuteSimulation_SimulationState_Continuous_0.setTrigger(Event("Simulation.Pause", None))
 
         self.states["/Main/ExecuteSimulation/SimulationState/Continuous"].addTransition(_Main_ExecuteSimulation_SimulationState_Continuous_0)
 
+        _Main_ExecuteSimulation_SimulationState_Continuous_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Continuous"], [self.states["/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered"]])
 
+        _Main_ExecuteSimulation_SimulationState_Continuous_1.setAction(self._Main_ExecuteSimulation_SimulationState_Continuous_1_exec)
 
+        _Main_ExecuteSimulation_SimulationState_Continuous_1.setTrigger(None)
 
+        _Main_ExecuteSimulation_SimulationState_Continuous_1.setGuard(self._Main_ExecuteSimulation_SimulationState_Continuous_1_guard)
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Continuous"].addTransition(_Main_ExecuteSimulation_SimulationState_Continuous_1)
 
         
         # transition /Main/ExecuteSimulation/SimulationState/Realtime
 
         _Main_ExecuteSimulation_SimulationState_Realtime_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Realtime"], [self.states["/Main/ExecuteSimulation/SimulationState/Paused"]])
 
         _Main_ExecuteSimulation_SimulationState_Realtime_0.setTrigger(Event("Simulation.Pause", None))
 
         self.states["/Main/ExecuteSimulation/SimulationState/Realtime"].addTransition(_Main_ExecuteSimulation_SimulationState_Realtime_0)
 
+        _Main_ExecuteSimulation_SimulationState_Realtime_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Realtime"], [self.states["/Main/ExecuteSimulation/SimulationState/Paused/BreakpointTriggered"]])
 
+        _Main_ExecuteSimulation_SimulationState_Realtime_1.setAction(self._Main_ExecuteSimulation_SimulationState_Realtime_1_exec)
 
+        _Main_ExecuteSimulation_SimulationState_Realtime_1.setTrigger(None)
 
+        _Main_ExecuteSimulation_SimulationState_Realtime_1.setGuard(self._Main_ExecuteSimulation_SimulationState_Realtime_1_guard)
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Realtime"].addTransition(_Main_ExecuteSimulation_SimulationState_Realtime_1)
 
         
         # transition /Main/ExecuteSimulation/SimulationFlow/Stopped
 
         _Main_ExecuteSimulation_SimulationFlow_Stopped_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"], [self.states["/Main/ExecuteSimulation/SimulationFlow/Started"]])
 
@@ -732,18 +798,17 @@ class CBDSimulator(RuntimeClassBase):
 
         # transition /Main/ExecuteSimulation/SimulationFlow/Waiting
 
         _Main_ExecuteSimulation_SimulationFlow_Waiting_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"], [self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"]])
 
         _Main_ExecuteSimulation_SimulationFlow_Waiting_0.setTrigger(None)
 
-        _Main_ExecuteSimulation_SimulationFlow_Waiting_0.setGuard(self._Main_ExecuteSimulation_SimulationFlow_Waiting_0_guard)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"].addTransition(_Main_ExecuteSimulation_SimulationFlow_Waiting_0)
 
-        _Main_ExecuteSimulation_SimulationFlow_Waiting_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"], [self.states["/Main/ExecuteSimulation/SimulationFlow/Stopped"]])
 
-        _Main_ExecuteSimulation_SimulationFlow_Waiting_1.setAction(self._Main_ExecuteSimulation_SimulationFlow_Waiting_1_exec)
 
-        _Main_ExecuteSimulation_SimulationFlow_Waiting_1.setTrigger(None)
 
-        _Main_ExecuteSimulation_SimulationFlow_Waiting_1.setGuard(self._Main_ExecuteSimulation_SimulationFlow_Waiting_1_guard)
 
-        self.states["/Main/ExecuteSimulation/SimulationFlow/Waiting"].addTransition(_Main_ExecuteSimulation_SimulationFlow_Waiting_1)
 
         
         # transition /Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination
 
         _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"], [self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"]])
 
         _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_0.setTrigger(Event("_1after"))
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"].addTransition(_Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_0)
 
+        _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"], [self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"]])
 
+        _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1.setAction(self._Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1_exec)
 
+        _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1.setTrigger(None)
 
+        _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1.setGuard(self._Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1_guard)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/SettleBeforeCheckTermination"].addTransition(_Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1)
 
         
         # transition /Main/ExecuteSimulation/SimulationFlow/CheckTermination
 
         _Main_ExecuteSimulation_SimulationFlow_CheckTermination_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"], [self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"]])
 
@@ -766,11 +831,16 @@ class CBDSimulator(RuntimeClassBase):
 
         _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_0.setAction(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_0_exec)
 
         _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_0.setTrigger(Event("_2after"))
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"].addTransition(_Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_0)
 
-        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"], [self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"]])
 
+        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"], [self.states["/Main/ExecuteSimulation/SimulationFlow/CheckTermination"]])
 
         _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1.setAction(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1_exec)
 
         _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1.setTrigger(None)
 
         _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1.setGuard(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1_guard)
 
         self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"].addTransition(_Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1)
 
+        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"], [self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"]])
 
+        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2.setAction(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2_exec)
 
+        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2.setTrigger(None)
 
+        _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2.setGuard(self._Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2_guard)
 
+        self.states["/Main/ExecuteSimulation/SimulationFlow/WaitingRealtime"].addTransition(_Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2)
 
         
         # transition /Main/ExecuteSimulation/SimulationFlow/InitializingBigStep
 
         _Main_ExecuteSimulation_SimulationFlow_InitializingBigStep_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationFlow/InitializingBigStep"], [self.states["/Main/ExecuteSimulation/SimulationFlow/Executing"]])
 
@@ -897,6 +967,25 @@ class CBDSimulator(RuntimeClassBase):
 
         _Main_ExecuteBlock_Waiting_0.setAction(self._Main_ExecuteBlock_Waiting_0_exec)
 
         _Main_ExecuteBlock_Waiting_0.setTrigger(Event("Block.Execute", None))
 
         self.states["/Main/ExecuteBlock/Waiting"].addTransition(_Main_ExecuteBlock_Waiting_0)
 
+        
+        # transition /Main/SimulationCoordinator/ModeSelector/Running
 
+        _Main_SimulationCoordinator_ModeSelector_Running_0 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_0.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_0_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_0.setTrigger(Event("Simulation.Finished", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_0)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_1 = Transition(self, self.states["/Main/SimulationCoordinator/ModeSelector/Running"], [self.states["/Main/SimulationCoordinator/ModeSelector/Paused"]])
 
+        _Main_SimulationCoordinator_ModeSelector_Running_1.setAction(self._Main_SimulationCoordinator_ModeSelector_Running_1_exec)
 
+        _Main_SimulationCoordinator_ModeSelector_Running_1.setTrigger(Event("Breakpoint.Triggered", None))
 
+        self.states["/Main/SimulationCoordinator/ModeSelector/Running"].addTransition(_Main_SimulationCoordinator_ModeSelector_Running_1)
 
+        
+        # transition /Main/ExecuteSimulation/SimulationState/Paused
 
+        _Main_ExecuteSimulation_SimulationState_Paused_0 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Paused"], [self.states["/Main/ExecuteSimulation/SimulationState/Continuous"]])
 
+        _Main_ExecuteSimulation_SimulationState_Paused_0.setTrigger(Event("Simulation.Execute", None))
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].addTransition(_Main_ExecuteSimulation_SimulationState_Paused_0)
 
+        _Main_ExecuteSimulation_SimulationState_Paused_1 = Transition(self, self.states["/Main/ExecuteSimulation/SimulationState/Paused"], [self.states["/Main/ExecuteSimulation/SimulationState/Realtime"]])
 
+        _Main_ExecuteSimulation_SimulationState_Paused_1.setAction(self._Main_ExecuteSimulation_SimulationState_Paused_1_exec)
 
+        _Main_ExecuteSimulation_SimulationState_Paused_1.setTrigger(Event("Simulation.ExecuteRealtime", None))
 
+        self.states["/Main/ExecuteSimulation/SimulationState/Paused"].addTransition(_Main_ExecuteSimulation_SimulationState_Paused_1)
 
     
     def _Main_SimulationCoordinator_SimulationFlow_PrePaused_enter(self):
 
         self.addTimer(0, self.sccd_yield())
 
@@ -931,72 +1020,140 @@ class CBDSimulator(RuntimeClassBase):
 
     def _Main_ExecuteSmallStep_Executing_enter(self):
 
         self.raiseInternalEvent(Event("Block.Execute", None, []))
 
     
+    def _Main_SimulationCoordinator_ModeSelector_Running_0_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("Simulation.Finished", "user_output", []))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
+    def _Main_SimulationCoordinator_ModeSelector_Running_1_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("Breakpoint.Triggered", "user_output", [self.triggered_bp]))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
+    def _Main_ExecuteSimulation_SimulationState_Paused_1_exec(self, parameters):
 
+        realtime_scale = parameters[0]
 
+        self.realtime_scale = float(realtime_scale)
 
+        # If the simulation was paused, we need to reset the start time of the simulation.
 
+        # The start time of the simulation is equal to the point in wall-clock time where simulated time is 0.
 
+        # If the simulation was paused, we have to recompute this point in time: it is the difference of the wall-clock time and the simulated time.
 
+        # If the scale was changed after the pause, this point of course moves backwards (for scales smaller than 1) or forwards (for scales larger than 1)
 
+        self.realtime_start_time = accurate_time.time() - (self.clock / self.realtime_scale)
 
+    
     def _Main_SimulationCoordinator_ModeSelector_Paused_3_exec(self, parameters):
 
         realtime_scale = parameters[0]
 
         self.realtime_scale = realtime_scale
 
     
-    def _Main_SimulationCoordinator_ModeSelector_Continuous_1_exec(self, parameters):
 
+    def _Main_SimulationCoordinator_ModeSelector_Running_Continuous_0_exec(self, parameters):
 
         self.raiseInternalEvent(Event("Simulation.Pause", None, []))
 
     
-    def _Main_SimulationCoordinator_ModeSelector_Realtime_1_exec(self, parameters):
 
+    def _Main_SimulationCoordinator_ModeSelector_Running_Realtime_0_exec(self, parameters):
 
         self.raiseInternalEvent(Event("Simulation.Pause", None, []))
 
     
+    def _Main_SimulationCoordinator_ModeSelector_Running_Realtime_1_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("BigStep.Finished", "user_output", []))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
+    def _Main_SimulationCoordinator_ModeSelector_Running_BigStep_0_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("BigStep.Finished", "user_output", []))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
+    def _Main_SimulationCoordinator_ModeSelector_Running_SmallStep_0_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("SmallStep.Finished", "user_output", []))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
+    def _Main_SimulationCoordinator_ModeSelector_WaitingForPaused_0_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("Simulation.Paused", "user_output", []))
 
+        self.big_step.outputEvent(Event("State", "user_output", [self.clock / 1000.0]))
 
+    
     def _Main_SimulationCoordinator_Initializer_Waiting_0_exec(self, parameters):
 
         self.raiseInternalEvent(Event("Simulation.Reset", None, []))
 
     
     def _Main_SimulationCoordinator_Initializer_Waiting_0_guard(self, parameters):
 
-        return (self.inState(["/Main/SimulationCoordinator/ModeSelector/SmallStep"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/BigStep"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/Continuous"]) or (self.inState(["/Main/SimulationCoordinator/ModeSelector/Realtime"]))) and self.inState(["/Main/SimulationCoordinator/SimulationState/Uninitialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/SimulationState/Uninitialized"])
 
     
     def _Main_SimulationCoordinator_Initializer_Waiting_1_exec(self, parameters):
 
         self.raiseInternalEvent(Event("BigStep.Reset", None, []))
 
     
     def _Main_SimulationCoordinator_Initializer_Waiting_1_guard(self, parameters):
 
-        return (self.inState(["/Main/SimulationCoordinator/ModeSelector/SmallStep"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/BigStep"])) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Uninitialized"])
 
+        return (self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"])) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Uninitialized"])
 
     
     def _Main_SimulationCoordinator_Initializer_Waiting_2_exec(self, parameters):
 
         self.raiseInternalEvent(Event("SmallStep.Reset", None, []))
 
     
     def _Main_SimulationCoordinator_Initializer_Waiting_2_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/SmallStep"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Initialized"]) and self.inState(["/Main/SimulationCoordinator/SmallStepState/Uninitialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Initialized"]) and self.inState(["/Main/SimulationCoordinator/SmallStepState/Uninitialized"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_0_exec(self, parameters):
 
         self.raiseInternalEvent(Event("SmallStep.Execute", None, []))
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_0_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/SmallStep"]) and self.inState(["/Main/SimulationCoordinator/SmallStepState/Initialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/SmallStep"]) and self.inState(["/Main/SimulationCoordinator/SmallStepState/Initialized"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_1_exec(self, parameters):
 
         self.raiseInternalEvent(Event("BigStep.Execute", None, []))
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_1_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/BigStep"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Initialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/BigStep"]) and self.inState(["/Main/SimulationCoordinator/BigStepState/Initialized"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_2_exec(self, parameters):
 
         self.raiseInternalEvent(Event("Simulation.Execute", None, []))
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_2_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Continuous"]) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"]) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_3_exec(self, parameters):
 
         self.raiseInternalEvent(Event("Simulation.ExecuteRealtime", None, [self.realtime_scale]))
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Paused_3_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Realtime"]) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"]) and self.inState(["/Main/SimulationCoordinator/SimulationState/Initialized"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Executing_0_guard(self, parameters):
 
         return self.inState(["/Main/SimulationCoordinator/ModeSelector/Paused"])
 
     
     def _Main_SimulationCoordinator_SimulationFlow_Executing_1_guard(self, parameters):
 
-        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Continuous"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/Realtime"])
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/Continuous"]) or self.inState(["/Main/SimulationCoordinator/ModeSelector/Running/Realtime"])
 
     
-    def _Main_ExecuteSimulation_SimulationState_Paused_1_exec(self, parameters):
 
-        realtime_scale = parameters[0]
 
-        self.realtime_scale = float(realtime_scale)
 
-        # If the simulation was paused, we need to reset the start time of the simulation.
 
-        # The start time of the simulation is equal to the point in wall-clock time where simulated time is 0.
 
-        # If the simulation was paused, we have to recompute this point in time: it is the difference of the wall-clock time and the simulated time.
 
-        # If the scale was changed after the pause, this point of course moves backwards (for scales smaller than 1) or forwards (for scales larger than 1)
 
-        self.realtime_start_time = accurate_time.time() - (self.clock / self.realtime_scale)
 
+    def _Main_SimulationCoordinator_GodEventManager_Listening_0_exec(self, parameters):
 
+        block_name = parameters[0]
 
+        new_val = parameters[1]
 
+        result = self.godEvent(block_name, new_val)
 
+        self.big_step.outputEvent(Event("god_event_result", "user_output", [result]))
 
+    
+    def _Main_SimulationCoordinator_GodEventManager_Listening_0_guard(self, parameters):
 
+        block_name = parameters[0]
 
+        new_val = parameters[1]
 
+        return self.inState(["/Main/SimulationCoordinator/ModeSelector/Paused"])
 
+    
+    def _Main_SimulationCoordinator_BreakpointManager_Listening_0_exec(self, parameters):
 
+        name = parameters[0]
 
+        function = parameters[1]
 
+        enabled = parameters[2]
 
+        disable_on_trigger = parameters[3]
 
+        result = self.addBreakpoint(name, function, bool(enabled), bool(disable_on_trigger))
 
+        self.big_step.outputEvent(Event("add_breakpoint_result", "user_output", [result]))
 
+    
+    def _Main_SimulationCoordinator_BreakpointManager_Listening_1_exec(self, parameters):
 
+        name = parameters[0]
 
+        result = self.delBreakpoint(name)
 
+        self.big_step.outputEvent(Event("del_breakpoint_result", "user_output", [result]))
 
+    
+    def _Main_SimulationCoordinator_BreakpointManager_Listening_2_exec(self, parameters):
 
+        name = parameters[0]
 
+        result = self.toggleBreakpoint(name)
 
+        self.big_step.outputEvent(Event("toggle_breakpoint_result", "user_output", [result]))
 
+    
+    def _Main_SimulationCoordinator_BreakpointManager_Listening_3_exec(self, parameters):
 
+        self.big_step.outputEvent(Event("list_breakpoints_result", "user_output", [[bp.name for bp in self.breakpoints]]))
 
+    
+    def _Main_ExecuteSimulation_SimulationState_Continuous_1_exec(self, parameters):
 
+        self.raiseInternalEvent(Event("Breakpoint.Triggered", None, []))
 
+    
+    def _Main_ExecuteSimulation_SimulationState_Continuous_1_guard(self, parameters):
 
+        return self.breakpointTriggers(False)
 
+    
+    def _Main_ExecuteSimulation_SimulationState_Realtime_1_exec(self, parameters):
 
+        self.raiseInternalEvent(Event("Breakpoint.Triggered", None, []))
 
+    
+    def _Main_ExecuteSimulation_SimulationState_Realtime_1_guard(self, parameters):
 
+        return self.breakpointTriggers(True)
 
     
     def _Main_ExecuteSimulation_SimulationFlow_Started_0_exec(self, parameters):
 
         self.initializeSimulation()
 
@@ -1005,16 +1162,11 @@ class CBDSimulator(RuntimeClassBase):
 
         self.initializeSimulationDebugger()
 
         self.raiseInternalEvent(Event("Simulation.Initialized", None, []))
 
     
-    def _Main_ExecuteSimulation_SimulationFlow_Waiting_0_guard(self, parameters):
 
-        return self.inState(["/Main/ExecuteSimulation/SimulationState/Continuous"]) or self.inState(["/Main/ExecuteSimulation/SimulationState/Realtime"])
 
+    def _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1_exec(self, parameters):
 
+        self.raiseInternalEvent(Event("Simulation.Paused", None, []))
 
     
-    def _Main_ExecuteSimulation_SimulationFlow_Waiting_1_exec(self, parameters):
 
-        print 'simulation executed'
 
-        self.finalizeSimulation()
 
-        self.raiseInternalEvent(Event("Simulation.Finished", None, []))
 
-    
-    def _Main_ExecuteSimulation_SimulationFlow_Waiting_1_guard(self, parameters):
 
-        return self.endConditionSimulation()
 
+    def _Main_ExecuteSimulation_SimulationFlow_SettleBeforeCheckTermination_1_guard(self, parameters):
 
+        return self.inState(["/Main/ExecuteSimulation/SimulationState/Paused"])
 
     
     def _Main_ExecuteSimulation_SimulationFlow_CheckTermination_0_exec(self, parameters):
 
         self.raiseInternalEvent(Event("BigStep.Reset", None, []))
 
@@ -1037,9 +1189,15 @@ class CBDSimulator(RuntimeClassBase):
 
         self.syncSimulatedTime()
 
     
     def _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1_exec(self, parameters):
 
-        self.raiseInternalEvent(Event("BigStep.Reset", None, []))
 
+        self.raiseInternalEvent(Event("Simulation.Paused", None, []))
 
     
     def _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_1_guard(self, parameters):
 
+        return self.inState(["/Main/ExecuteSimulation/SimulationState/Paused"])
 
+    
+    def _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2_exec(self, parameters):
 
+        self.raiseInternalEvent(Event("BigStep.Reset", None, []))
 
+    
+    def _Main_ExecuteSimulation_SimulationFlow_WaitingRealtime_2_guard(self, parameters):
 
         return self.waitTime() / 1000.0 <= self.sccd_yield()
 
     
     def _Main_ExecuteSimulation_SimulationFlow_InitializingBigStep_0_exec(self, parameters):