import from SVN

fsa_cbd_composition/cbd_tfsa_simulator/.project

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>cbd_tfsa_simulator</name>
+	<comment></comment>
+	<projects>
+		<project>cbdsimulator</project>
+		<project>fsasimulator</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

fsa_cbd_composition/cbd_tfsa_simulator/.pydevproject

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+<path>/${PROJECT_DIR_NAME}</path>
+<path>/${PROJECT_DIR_NAME}/models</path>
+</pydev_pathproperty>
+</pydev_project>

fsa_cbd_composition/cbd_tfsa_simulator/cbd_tfsa_woven_classes.py

@@ -0,0 +1,68 @@
+from CBDMultipleOutput.Source.CBD import BaseBlock
+from fsaclasses import Event, RunTimeEvent, State
+
+class FSA_SemanticAdaptation():
+    @staticmethod
+    def getEventsTriggeredByZeroCrossing(time, fsaBlock, currentState):
+        '''
+        Returns a list of events scheduled to now that indicate that certain transitions became enabled.
+        '''
+        events = []
+        input_ports = fsaBlock.getLinksIn().keys()
+        for t in fsaBlock.fsa.transitions:
+            if t.source == currentState and isinstance(t.trigger,WhenVarCrossesThresholdTrigger):
+                # check whether the input values presented to the fsaBlock have crossed the thresholds.
+                # I don't like short circuiting ands, so I have multiple cascading ifs.
+                if t.trigger.varname in input_ports:
+                    inputValue = fsaBlock.getInputSignal(None, input_port=t.trigger.varname).value
+                    if t.trigger.op == "<":
+                        if inputValue < t.trigger.threshold:
+                            events.append(RunTimeEvent(t.trigger.eventName,time))
+                    elif t.trigger.op == ">":
+                        if inputValue > t.trigger.threshold:
+                            events.append(RunTimeEvent(t.trigger.eventName,time))
+                    else:
+                        raise NotImplementedError("Operator not supported.")
+        
+        if len(events)>1:
+            raise NotImplemented("Multiple threshold crossings found. This is non-deterministic: " + events)
+        
+        print "Threshold crossing events at " + str(time) + " for block " + fsaBlock.getBlockName() + ": " + str(events)
+        
+        return events
+    
+    @staticmethod
+    def updateOutputFSA(iteration, time, fsaBlock, fsaState):
+        '''
+        Updates the output port of the fsaBlock with the value representative of the current state.
+        '''
+        assert isinstance(fsaBlock, FSABlock)
+        assert len(fsaBlock.getOutputPorts()) <= 1
+        if len(fsaBlock.getOutputPorts()) == 0:
+            # Nothing to do
+            return 
+        
+        output_port = fsaBlock.getOutputPorts()[0]
+        assert isinstance(fsaState, ValuedState)
+        assert len(fsaBlock.getSignal(output_port)) == iteration
+        fsaBlock.appendToSignal(fsaState.value, output_port)
+        
+    
+class FSABlock(BaseBlock):
+    def __init__(self, name, fsaModel, input_ports, output_ports):
+        BaseBlock.__init__(self, name, input_ports, output_ports)
+        self.fsa = fsaModel
+
+class WhenVarCrossesThresholdTrigger(Event):
+    def __init__(self, varname, threshold, operation):
+        self.varname = varname
+        self.threshold = threshold
+        self.op = operation
+        self.eventName = varname+operation+str(threshold)
+        Event.__init__(self, self.eventName)
+
+class ValuedState(State):
+    def __init__(self, name, value):
+        State.__init__(self, name)
+        self.value = value
+        

fsa_cbd_composition/cbd_tfsa_simulator/events.csv

@@ -0,0 +1,7 @@
+fsa,Event,time
+controller,up>0.5,0.0
+controller,force>100,4.009999999999959
+controller,after(1.0),5.009999999999938
+controller,up>0.5,5.019999999999937
+controller,up<0.5,6.009999999999916
+controller,up>0.5,7.009999999999895

fsa_cbd_composition/cbd_tfsa_simulator/models/powerwindow.py

@@ -0,0 +1,120 @@
+from CBDMultipleOutput.Source.CBD import CBD, ConstantBlock, \
+    AdderBlock, BaseBlock, ProductBlock, IntegratorBlock
+from cbd_tfsa_woven_classes import FSABlock, WhenVarCrossesThresholdTrigger,\
+    ValuedState
+from fsaclasses import FSAModel, Transition, After, Float
+
+class PowerWindowCBD(CBD):
+    def __init__(self, blockName, delta_t = 0.01):
+        CBD.__init__(self,blockName, input_ports=[], output_ports=[])
+        self.addBlock(ConstantBlock("delta", value=delta_t))
+        self.addBlock(Environment("environment"))
+        self.addBlock(InterfaceFSA("controller"))
+        self.addBlock(PowerWindowPlant("plant"))
+        
+        self.addConnection("environment", "controller", 
+                           input_port_name="force", output_port_name="force")
+        self.addConnection("environment", "controller", 
+                           input_port_name="down", output_port_name="down")
+        self.addConnection("environment", "controller", 
+                           input_port_name="up", output_port_name="up")
+        
+        self.addConnection("controller", "plant", 
+                           input_port_name="motor", output_port_name="motor")
+        self.addConnection("delta", "plant", 
+                           input_port_name="delta_t")
+        
+    def setDeltaT(self, deltaT):
+        CBD.setDeltaT(self, deltaT)
+        self.getBlockByName("delta").setValue(deltaT);
+
+class Environment(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, [], ["force","down","up"])
+        self.__values = []
+    
+    def compute(self, curIteration):
+        time = self.getClock().getTime()
+        
+        force_value = 0.0
+        down_value = 0.0
+        up_value = 0.0
+        
+        if time < 6.0:
+            up_value = 1.0
+        elif time < 7.0:
+            up_value = 0.0
+        else:
+            up_value = 1.0
+        
+        if time < 4.0:
+            force_value = 0.0
+        elif time < 4.5:
+            force_value = 150.0
+        else:
+            force_value = 0.0
+        
+        self.appendToSignal(force_value, "force")
+        self.appendToSignal(down_value, "down")
+        self.appendToSignal(up_value, "up")
+
+class InterfaceFSA(FSABlock):
+    def __init__(self, name):
+        
+        s_down = ValuedState("down", -1.0)
+        s_neutral = ValuedState("neutral", 0.0)
+        s_up = ValuedState("up", 1.0)
+        s_emergency = ValuedState("emergency", -1.0)
+        
+        t_neutral_down = Transition("neutral_down",s_neutral,s_down)
+        t_neutral_down.trigger = WhenVarCrossesThresholdTrigger("down", 0.5, ">")
+        t_down_neutral = Transition("down_neutral",s_down, s_neutral)
+        t_down_neutral.trigger = WhenVarCrossesThresholdTrigger("down", 0.5, "<")
+        
+        t_neutral_up = Transition("neutral_up",s_neutral, s_up)
+        t_neutral_up.trigger = WhenVarCrossesThresholdTrigger("up", 0.5, ">")
+        t_up_neutral = Transition("up_neutral",s_up, s_neutral)
+        t_up_neutral.trigger = WhenVarCrossesThresholdTrigger("up", 0.5, "<")
+        
+        t_up_emergency = Transition("up_emergency",s_up, s_emergency)
+        t_up_emergency.trigger = WhenVarCrossesThresholdTrigger("force", 100, ">")
+        
+        t_emergency_neutral = Transition("emergency_neutral",s_emergency, s_neutral)
+        t_emergency_neutral.trigger = After(Float(1.0))
+        
+        fsaModel = FSAModel(
+                        [s_down,s_neutral,s_up,s_emergency],
+                        [t_neutral_down,t_down_neutral,
+                         t_neutral_up,t_up_neutral,
+                         t_up_emergency,t_emergency_neutral]
+                        )
+        fsaModel.initialState = s_neutral
+        
+        FSABlock.__init__(self, name, fsaModel, ["down", "up", "force"], ["motor"])
+
+
+class PowerWindowPlant(CBD):
+    def __init__(self, blockName, delta_t = 0.01):
+        CBD.__init__(self,blockName, input_ports=["motor", "delta_t"], output_ports=["position"])
+        self.addBlock(ConstantBlock("180", value=180.0))
+        self.addBlock(ProductBlock("times_180"))
+        self.addConnection("motor", "times_180")
+        self.addConnection("180", "times_180")
+        self.addBlock(AdderBlock("plus"))
+        self.addConnection("times_180", "plus")
+        self.addBlock(ConstantBlock("zero", value=0.0))
+        self.addBlock(IntegratorBlock("velocity"))
+        self.addConnection("zero", "velocity", input_port_name="IC")
+        self.addConnection("delta_t", "velocity", input_port_name="delta_t")
+        self.addConnection("plus", "velocity")
+        self.addBlock(ConstantBlock("minus10", value=-10.0))
+        self.addBlock(ProductBlock("times_minus_10"))
+        self.addConnection("minus10", "times_minus_10")
+        self.addConnection("velocity", "times_minus_10")
+        self.addConnection("times_minus_10", "plus")
+        self.addBlock(IntegratorBlock("pos"))
+        self.addConnection("zero", "pos", input_port_name="IC")
+        self.addConnection("delta_t", "pos", input_port_name="delta_t")
+        self.addConnection("velocity", "pos")
+        self.addConnection("pos", "position")
+    

fsa_cbd_composition/cbd_tfsa_simulator/plotSignals.r

@@ -0,0 +1,61 @@
+library(ggplot2)
+library(cowplot)
+
+signals = read.csv("./signals.csv")
+states = read.csv("./states.csv")
+events = read.csv("./events.csv")
+
+events_expanded <- merge(signals,events,by="time", all=TRUE)
+
+point_size <- 0.05
+
+events <- ggplot(data=events_expanded , aes(x=time, y=Event, group=fsa)) +
+  geom_point(na.rm = FALSE, size = point_size) +
+  ylab("Event") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("Event", labels = waiver(), limits=c("force>100", "up>0.5")) +
+  theme(axis.title.y=element_text(vjust=0))
+
+states <- ggplot(data=states , aes(x=time, y=value, group=fsa)) +
+  geom_point(size = point_size) +
+  ylab("State") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("State", labels = waiver()) +
+  theme(axis.title.y=element_text(vjust=0))
+
+up_data = signals[which(signals$signal == "s_powerwindow_environment_up"), ]
+
+up <- ggplot(data=up_data , aes(x=time, y=value, group=signal)) +
+  #geom_point(size = point_size) +
+  geom_line(size=point_size/2) + 
+  ylab("Up") +
+  xlab("Time (s)") +
+  theme(axis.title.y=element_text(vjust=0))
+
+force_data = signals[which(signals$signal == "s_powerwindow_environment_force"), ]
+
+force <- ggplot(data=force_data , aes(x=time, y=value, group=signal)) +
+  #geom_point(size = point_size) +
+  geom_line(size=point_size/2) + 
+  ylab("Force") +
+  xlab("Time (s)") +
+  theme(axis.title.y=element_text(vjust=0))
+
+
+position_data = signals[which(signals$signal == "s_powerwindow_plant_position"), ]
+
+position <- ggplot(data=position_data , aes(x=time, y=value, group=signal)) +
+        geom_point(size = point_size) +
+        ylab("Position ") + 
+        xlab("Time (s)") +
+        theme(axis.title.y=element_text(vjust=0))
+
+nrow <- 5
+ncol <- 1
+
+multiplot <- plot_grid(up, force, events, states, position , nrow = nrow, ncol = ncol, align = "v")
+multiplot_pf <- plot_grid(force, position , nrow = 1, ncol = 2, align = "h")
+
+save_plot("plots.pdf", multiplot, nrow = nrow, ncol = ncol, base_aspect_ratio = 1.0)
+save_plot("plots_pf_pw.pdf", multiplot, nrow = 1, ncol = 2, base_aspect_ratio = 1.0)
+

fsa_cbd_composition/cbd_tfsa_simulator/woven_cbd_tfsa_lib.py

@@ -0,0 +1,107 @@
+'''
+@author: Claudio Gomes, Bruno Barroca and Sadaf Mustafiz
+'''
+import os
+from CBDMultipleOutput.Source.CBD import CBD
+import csv
+from cbd_tfsa_woven_classes import FSABlock, WhenVarCrossesThresholdTrigger
+from fsaclasses import Event, After
+
+class CBDFSAPlotter():
+	
+	OUTPUT_SIGNALS = "./signals.csv"
+	OUTPUT_STATES = "./states.csv"
+	OUTPUT_EVENTS = "./events.csv"
+	
+	def __init__(self, cbd_model):
+		if os.path.exists(CBDFSAPlotter.OUTPUT_SIGNALS):
+			os.remove(CBDFSAPlotter.OUTPUT_SIGNALS)
+		if os.path.exists(CBDFSAPlotter.OUTPUT_EVENTS):
+			os.remove(CBDFSAPlotter.OUTPUT_EVENTS)
+		if os.path.exists(CBDFSAPlotter.OUTPUT_STATES):
+			os.remove(CBDFSAPlotter.OUTPUT_STATES)
+		self.wroteSignalsHeaders = False
+		self.wroteEventHeaders = False
+		self.wroteStateHeaders = False
+		self.cbd_model = cbd_model
+		
+	def store(self, iteration, time, woven_current_state_fsas):
+		signal_rows = []
+		state_rows = []
+		
+		def recAddSignalsToDict(block, prefix):
+			if (isinstance(block, CBD)):
+				for innerBlock in block.getBlocks():
+					recAddSignalsToDict(innerBlock, prefix+"_"+block.getBlockName())
+			
+			if isinstance(block, FSABlock):
+				currentState = woven_current_state_fsas[block.getBlockName()]
+				row = dict()
+				row["time"] = time
+				row["iteration"] = iteration
+				row["fsa"] = prefix+"_"+block.getBlockName()
+				row["value"] = currentState.getName()
+				state_rows.append(row)
+			
+			for outPort in block.getOutputPorts():
+				row = dict()
+				row["time"] = time
+				row["iteration"] = iteration
+				row["signal"] = prefix+"_"+block.getBlockName()+"_"+outPort
+				row["value"] = block.getSignal(outPort)[iteration].value
+				signal_rows.append(row)
+				
+		recAddSignalsToDict(self.cbd_model, "s")
+		
+		with open(CBDFSAPlotter.OUTPUT_SIGNALS, "a") as csvFile:
+				writerCsv = csv.DictWriter(csvFile, fieldnames=signal_rows[0].keys())
+				if not self.wroteSignalsHeaders:
+					writerCsv.writeheader()
+					self.wroteSignalsHeaders = True
+				writerCsv.writerows(signal_rows)
+		
+		if len(state_rows)>0:
+			with open(CBDFSAPlotter.OUTPUT_STATES, "a") as csvFile:
+					writerCsv = csv.DictWriter(csvFile, fieldnames=state_rows[0].keys())
+					if not self.wroteStateHeaders:
+						writerCsv.writeheader()
+						self.wroteStateHeaders = True
+					writerCsv.writerows(state_rows)
+	
+	
+	def storeDiscreteEvent(self, fsa_block, fsa_logicalTime, fsa_currentState , fsa_selectedTransition):
+		event = None
+		if (fsa_selectedTransition != None):
+			if fsa_selectedTransition.trigger != None:
+				if isinstance(fsa_selectedTransition.trigger, Event):
+					event = fsa_selectedTransition.trigger.name
+				elif isinstance(fsa_selectedTransition.trigger, After):
+					event = "after("+str(fsa_selectedTransition.trigger.after)+")"
+				else:
+					raise NotImplementedError()
+		
+		if (event != None):
+			with open(CBDFSAPlotter.OUTPUT_EVENTS, "a") as csvFile:
+				eventDict = {"time" : fsa_logicalTime , "Event" : event, "fsa": fsa_block.getBlockName()}
+				writerCsv = csv.DictWriter(csvFile, fieldnames=eventDict.keys())
+				if not self.wroteEventHeaders:
+					writerCsv.writeheader()
+					self.wroteEventHeaders = True
+				writerCsv.writerow(eventDict)
+		
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+				

fsa_cbd_composition/cbd_tfsa_simulator/woven_cbd_tfsa_simulator.py

@@ -0,0 +1,968 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe and Joeri Exelmans
+
+Date:   Sun Dec 13 19:39:13 2015
+
+Model author: Sadaf Mustafiz and Bruno Barroca and Claudio Gomes
+Model name:   Woven_CBD_FSA_Simulator_Automatic
+Model description:
+Automatically woven CBD and FSA simulators with the CBD being the dominant.
+"""
+
+from python_runtime.statecharts_core import *
+from python_runtime.libs.ui import *
+from python_runtime.libs.utils import *
+from CBD_Controller import CBDController
+from cbd_tfsa_woven_classes import FSABlock
+from cbd_tfsa_woven_classes import FSA_SemanticAdaptation
+from fsaclasses import Events
+
+# package "Woven_CBD_FSA_Simulator_Automatic"
+
+class Woven_CBD_TFSA_Simulator(RuntimeClassBase):
+	def __init__(self, controller, cbd_options, amodel, plotter):
+		RuntimeClassBase.__init__(self, controller)
+		
+		self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+		self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+		self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+		self.semantics.priority = StatechartSemantics.SourceParent
+		self.semantics.concurrency = StatechartSemantics.Single
+		
+		# User defined attributes
+		self.fsa_currentState = None
+		self.cbd_delta = None
+		self.woven_processing_fsa = None
+		self.fsa_eventList = None
+		self.cbd_strongComponentList = None
+		self.cbd_clock = None
+		self.cbd_iteration = None
+		self.fsa_elapsed = None
+		self.plotter = None
+		self.cbd_depGraph = None
+		self.cbd_currentCompIdx = None
+		self.woven_ended_fsa = None
+		self.fsa_timestep = None
+		self.fsa_logicalTime = None
+		self.cbd_model = None
+		self.woven_logical_time_fsas = None
+		self.woven_step_executed = None
+		self.woven_current_state_fsas = None
+		self.cbd_controller = None
+		self.fsa_selectedTransition = None
+		self.fsa_model = None
+		self.fsa_currentEvent = None
+		self.woven_delta = None
+		self.woven_elapsed_fsas = None
+		self.cbd_options = None
+		
+		# Call user defined constructor
+		Woven_CBD_TFSA_Simulator.user_defined_constructor(self, cbd_options, amodel, plotter)
+	
+	def user_defined_constructor(self, cbd_options, amodel, plotter):
+		self.cbd_options = cbd_options
+		self.cbd_delta = self.cbd_options.getDeltaT()
+		self.cbd_model = amodel
+		self.plotter = plotter
+		self.woven_processing_fsa = dict()
+		self.woven_step_executed = dict()
+		self.woven_ended_fsa = dict()
+		self.woven_logical_time_fsas = dict()
+		self.woven_elapsed_fsas = dict()
+		self.woven_current_state_fsas = dict()
+		self.fsa_timestep = 1.0
+	
+	def user_defined_destructor(self):
+		pass
+	
+	
+	# User defined method
+	def woven_updateEventsTriggeredByZeroCrossing(self, time, fsaBlock, fsaState):
+		self.fsa_eventList = Events(FSA_SemanticAdaptation.getEventsTriggeredByZeroCrossing(time, fsaBlock, fsaState))
+	
+	
+	# User defined method
+	def cbd_maxIterationsReached(self):
+		return self.cbd_iteration >= self.cbd_options.getMaxIterations()
+	
+	
+	# User defined method
+	def woven_updateOutputFSA(self, iteration, time, fsaBlock, fsaState):
+		FSA_SemanticAdaptation.updateOutputFSA(iteration, time, fsaBlock, fsaState)
+	
+	
+	# User defined method
+	def fsa_getInputEventAt(self, time):
+		return self.fsa_eventList.getInputAt(time)
+	
+	
+	# User defined method
+	def fsa_processEvent(self, event):
+		if (event != None):
+			self.fsa_eventList.popEvent(event)
+			event.processed = True
+	
+	
+	# User defined method
+	def cbd_computeBlock(self):
+		if self.cbd_currentComponentIsCycle():
+			self.cbd_controller.computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+		else:
+			self.cbd_controller.computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+	
+	
+	# User defined method
+	def cbd_currentComponentIsCycle(self):
+		return self.cbd_controller.componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+	
+	
+	# User defined method
+	def cbd_hasNextStrongComponent(self):
+		return self.cbd_currentCompIdx < len(self.cbd_strongComponentList)
+	
+	def initializeStatechart(self):
+		self.current_state[self.Root] = []
+		self.current_state[self.Root_FSA] = []
+		self.current_state[self.Root_CBD] = []
+		
+		# Enter default state
+		self.enterDefault_Root_CBD()
+	
+	# Unique IDs for all statechart nodes
+	Root = 0
+	Root_FSA = 1
+	Root_CBD = 2
+	Root_ChildInitialized = 3
+	Root_ChildNotInitialized = 4
+	Root_ChildProcessed = 5
+	Root_ChildDetected = 6
+	Root_ChildPaused = 7
+	Root_HybridTerminated = 8
+	Root_ChildNotDetected = 9
+	Root_FSA_Started = 10
+	Root_FSA_Terminated = 11
+	Root_FSA_Initialized = 12
+	Root_FSA_MacroStepProcessed = 13
+	Root_FSA_MicroStepProcessed = 14
+	Root_FSA_MacroStepPrepared = 15
+	Root_FSA_MicroStepPrepared = 16
+	Root_ParentPaused = 17
+	Root_CBD_Terminated = 18
+	Root_CBD_MacroStepPrepared = 19
+	Root_CBD_Started = 20
+	Root_CBD_Initialized = 21
+	Root_CBD_MacroStepProcessed = 22
+	Root_CBD_MicroStepPrepared = 23
+	Root_CBD_MicroStepProcessed = 24
+	
+	# Statechart enter/exit action method(s)
+	
+	def enter_Root_FSA(self):
+		self.current_state[self.Root].append(self.Root_FSA)
+	
+	def exit_Root_FSA(self):
+		if self.Root_FSA_Started in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_Started()
+		if self.Root_FSA_Terminated in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_Terminated()
+		if self.Root_FSA_Initialized in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_Initialized()
+		if self.Root_FSA_MacroStepProcessed in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_MacroStepProcessed()
+		if self.Root_FSA_MicroStepProcessed in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_MicroStepProcessed()
+		if self.Root_FSA_MacroStepPrepared in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_MacroStepPrepared()
+		if self.Root_FSA_MicroStepPrepared in self.current_state[self.Root_FSA]:
+			self.exit_Root_FSA_MicroStepPrepared()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_CBD(self):
+		self.current_state[self.Root].append(self.Root_CBD)
+	
+	def exit_Root_CBD(self):
+		if self.Root_CBD_Terminated in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_Terminated()
+		if self.Root_CBD_MacroStepPrepared in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_MacroStepPrepared()
+		if self.Root_CBD_Started in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_Started()
+		if self.Root_CBD_Initialized in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_Initialized()
+		if self.Root_CBD_MacroStepProcessed in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_MacroStepProcessed()
+		if self.Root_CBD_MicroStepPrepared in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_MicroStepPrepared()
+		if self.Root_CBD_MicroStepProcessed in self.current_state[self.Root_CBD]:
+			self.exit_Root_CBD_MicroStepProcessed()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildInitialized(self):
+		self.current_state[self.Root].append(self.Root_ChildInitialized)
+	
+	def exit_Root_ChildInitialized(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildNotInitialized(self):
+		self.current_state[self.Root].append(self.Root_ChildNotInitialized)
+	
+	def exit_Root_ChildNotInitialized(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildProcessed(self):
+		self.current_state[self.Root].append(self.Root_ChildProcessed)
+	
+	def exit_Root_ChildProcessed(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildDetected(self):
+		self.current_state[self.Root].append(self.Root_ChildDetected)
+	
+	def exit_Root_ChildDetected(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildPaused(self):
+		self.current_state[self.Root].append(self.Root_ChildPaused)
+	
+	def exit_Root_ChildPaused(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_HybridTerminated(self):
+		self.current_state[self.Root].append(self.Root_HybridTerminated)
+	
+	def exit_Root_HybridTerminated(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ChildNotDetected(self):
+		self.current_state[self.Root].append(self.Root_ChildNotDetected)
+	
+	def exit_Root_ChildNotDetected(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_FSA_Started(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_Started)
+	
+	def exit_Root_FSA_Started(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_Terminated(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_Terminated)
+	
+	def exit_Root_FSA_Terminated(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_Initialized(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_Initialized)
+	
+	def exit_Root_FSA_Initialized(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_MacroStepProcessed(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_MacroStepProcessed)
+	
+	def exit_Root_FSA_MacroStepProcessed(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_MicroStepProcessed(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_MicroStepProcessed)
+	
+	def exit_Root_FSA_MicroStepProcessed(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_MacroStepPrepared(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_MacroStepPrepared)
+	
+	def exit_Root_FSA_MacroStepPrepared(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_FSA_MicroStepPrepared(self):
+		self.current_state[self.Root_FSA].append(self.Root_FSA_MicroStepPrepared)
+	
+	def exit_Root_FSA_MicroStepPrepared(self):
+		self.current_state[self.Root_FSA] = []
+	
+	def enter_Root_ParentPaused(self):
+		self.current_state[self.Root].append(self.Root_ParentPaused)
+	
+	def exit_Root_ParentPaused(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_CBD_Terminated(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_Terminated)
+	
+	def exit_Root_CBD_Terminated(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_MacroStepPrepared(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_MacroStepPrepared)
+	
+	def exit_Root_CBD_MacroStepPrepared(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_Started(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_Started)
+	
+	def exit_Root_CBD_Started(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_Initialized(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_Initialized)
+	
+	def exit_Root_CBD_Initialized(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_MacroStepProcessed(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_MacroStepProcessed)
+	
+	def exit_Root_CBD_MacroStepProcessed(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_MicroStepPrepared(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_MicroStepPrepared)
+	
+	def exit_Root_CBD_MicroStepPrepared(self):
+		self.current_state[self.Root_CBD] = []
+	
+	def enter_Root_CBD_MicroStepProcessed(self):
+		self.current_state[self.Root_CBD].append(self.Root_CBD_MicroStepProcessed)
+	
+	def exit_Root_CBD_MicroStepProcessed(self):
+		self.current_state[self.Root_CBD] = []
+	
+	# Statechart enter/exit default method(s)
+	
+	def enterDefault_Root_FSA(self):
+		self.enter_Root_FSA()
+		self.enter_Root_FSA_Started()
+	
+	def enterDefault_Root_CBD(self):
+		self.enter_Root_CBD()
+		self.enter_Root_CBD_Started()
+	
+	# Statechart transitions
+	
+	def generateCandidatesChildren_Root(self):
+		if self.current_state[self.Root][0] == self.Root_ChildInitialized:
+			return self.generateCandidates_Root_ChildInitialized()
+		elif self.current_state[self.Root][0] == self.Root_ChildNotInitialized:
+			return self.generateCandidates_Root_ChildNotInitialized()
+		elif self.current_state[self.Root][0] == self.Root_ChildProcessed:
+			return self.generateCandidates_Root_ChildProcessed()
+		elif self.current_state[self.Root][0] == self.Root_ChildDetected:
+			return self.generateCandidates_Root_ChildDetected()
+		elif self.current_state[self.Root][0] == self.Root_ChildPaused:
+			return self.generateCandidates_Root_ChildPaused()
+		elif self.current_state[self.Root][0] == self.Root_HybridTerminated:
+			return self.generateCandidates_Root_HybridTerminated()
+		elif self.current_state[self.Root][0] == self.Root_ChildNotDetected:
+			return self.generateCandidates_Root_ChildNotDetected()
+		elif self.current_state[self.Root][0] == self.Root_FSA:
+			return self.generateCandidates_Root_FSA()
+		elif self.current_state[self.Root][0] == self.Root_ParentPaused:
+			return self.generateCandidates_Root_ParentPaused()
+		elif self.current_state[self.Root][0] == self.Root_CBD:
+			return self.generateCandidates_Root_CBD()
+		return False
+	
+	def generateCandidates_Root(self):
+		if not self.combo_step.isArenaChanged(self.Root):
+			return self.generateCandidatesChildren_Root()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_ChildInitialized(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_ChildInitialized_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_ChildInitialized(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildInitialized):
+			return self.generateCandidatesCurrent_Root_ChildInitialized()
+		else:
+			return True
+	
+	def transition_Root_ChildInitialized_1(self, parameters):
+		self.exit_Root_ChildInitialized()
+		print('From ChildInitialized to CBD/MacroStepProcessed... ')
+		comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+		self.fsa_logicalTime = self.woven_logical_time_fsas[comp.getBlockName()]
+		self.fsa_elapsed = self.woven_elapsed_fsas[comp.getBlockName()]
+		self.fsa_currentState = self.woven_current_state_fsas[comp.getBlockName()]
+		self.fsa_model = comp.fsa
+		self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+		self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+		self.woven_updateEventsTriggeredByZeroCrossing(self.fsa_logicalTime, comp, self.fsa_currentState)
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_FSA()
+		self.enter_Root_FSA_MacroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_ChildNotInitialized(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_ChildNotInitialized_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_ChildNotInitialized(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildNotInitialized):
+			return self.generateCandidatesCurrent_Root_ChildNotInitialized()
+		else:
+			return True
+	
+	def transition_Root_ChildNotInitialized_1(self, parameters):
+		self.exit_Root_ChildNotInitialized()
+		print('From ChildNotInitialized to CBD/Started... ')
+		comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+		self.fsa_model = comp.fsa
+		self.woven_updateEventsTriggeredByZeroCrossing(self.cbd_clock, comp, comp.fsa.initialState)
+		self.woven_processing_fsa[comp.getBlockName()] = True
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_FSA()
+		self.enter_Root_FSA_Started()
+	
+	def generateCandidatesCurrent_Root_ChildProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_ChildProcessed_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_ChildProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildProcessed):
+			return self.generateCandidatesCurrent_Root_ChildProcessed()
+		else:
+			return True
+	
+	def transition_Root_ChildProcessed_1(self, parameters):
+		self.exit_Root_ChildProcessed()
+		print('From ChildProcessed to CBD/MicroStepProcessed and incrementing cbd_currentCompIdx...')
+		self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_CBD()
+		self.enter_Root_CBD_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_ChildDetected(self):
+		enabled_events = self.getEnabledEvents()
+		if not self.woven_processing_fsa.has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0].getBlockName()) or not self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0].getBlockName()]:
+			self.small_step.addCandidate(self.transition_Root_ChildDetected_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.woven_processing_fsa.has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0].getBlockName()) and self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0].getBlockName()]:
+			self.small_step.addCandidate(self.transition_Root_ChildDetected_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_ChildDetected(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildDetected):
+			return self.generateCandidatesCurrent_Root_ChildDetected()
+		else:
+			return True
+	
+	def transition_Root_ChildDetected_1(self, parameters):
+		self.exit_Root_ChildDetected()
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildNotInitialized()
+	
+	def transition_Root_ChildDetected_2(self, parameters):
+		self.exit_Root_ChildDetected()
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildInitialized()
+	
+	def generateCandidatesCurrent_Root_ChildPaused(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_ChildPaused_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_ChildPaused(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildPaused):
+			return self.generateCandidatesCurrent_Root_ChildPaused()
+		else:
+			return True
+	
+	def transition_Root_ChildPaused_1(self, parameters):
+		self.exit_Root_ChildPaused()
+		print('From ChildPaused to ChildProcessed...')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildProcessed()
+	
+	def generateCandidates_Root_HybridTerminated(self):
+		return False
+	
+	def generateCandidatesCurrent_Root_ChildNotDetected(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_ChildNotDetected_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_ChildNotDetected(self):
+		if not self.combo_step.isArenaChanged(self.Root_ChildNotDetected):
+			return self.generateCandidatesCurrent_Root_ChildNotDetected()
+		else:
+			return True
+	
+	def transition_Root_ChildNotDetected_1(self, parameters):
+		self.exit_Root_ChildNotDetected()
+		print('From ChildProcessed to CBD/MicroStepPrepared...')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_CBD()
+		self.enter_Root_CBD_MicroStepPrepared()
+	
+	def generateCandidatesChildren_Root_FSA(self):
+		if self.current_state[self.Root_FSA][0] == self.Root_FSA_Started:
+			return self.generateCandidates_Root_FSA_Started()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_Terminated:
+			return self.generateCandidates_Root_FSA_Terminated()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_Initialized:
+			return self.generateCandidates_Root_FSA_Initialized()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_MacroStepProcessed:
+			return self.generateCandidates_Root_FSA_MacroStepProcessed()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_MicroStepProcessed:
+			return self.generateCandidates_Root_FSA_MicroStepProcessed()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_MacroStepPrepared:
+			return self.generateCandidates_Root_FSA_MacroStepPrepared()
+		elif self.current_state[self.Root_FSA][0] == self.Root_FSA_MicroStepPrepared:
+			return self.generateCandidates_Root_FSA_MicroStepPrepared()
+		return False
+	
+	def generateCandidates_Root_FSA(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA):
+			return self.generateCandidatesChildren_Root_FSA()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_FSA_Started(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_FSA_Started_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_FSA_Started(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_Started):
+			return self.generateCandidatesCurrent_Root_FSA_Started()
+		else:
+			return True
+	
+	def transition_Root_FSA_Started_1(self, parameters):
+		self.exit_Root_FSA_Started()
+		print('From FSA/Started to Initialized... ')
+		self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+		self.fsa_logicalTime = 0.0
+		self.fsa_elapsed = 0
+		self.fsa_timestep = self.weaved_delta
+		self.fsa_currentState = self.fsa_model.initialState
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_Initialized()
+	
+	def generateCandidatesCurrent_Root_FSA_Terminated(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_FSA_Terminated_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_FSA_Terminated(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_Terminated):
+			return self.generateCandidatesCurrent_Root_FSA_Terminated()
+		else:
+			return True
+	
+	def transition_Root_FSA_Terminated_1(self, parameters):
+		self.exit_Root_FSA()
+		print('From FSA/Terminated to HybridTerminated... ')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_HybridTerminated()
+	
+	def generateCandidatesCurrent_Root_FSA_Initialized(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_FSA_Initialized_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_FSA_Initialized(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_Initialized):
+			return self.generateCandidatesCurrent_Root_FSA_Initialized()
+		else:
+			return True
+	
+	def transition_Root_FSA_Initialized_1(self, parameters):
+		self.exit_Root_FSA_Initialized()
+		print('From FSA/Initialized to MacroStepProcessed... ')
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MacroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_FSA_MacroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if self.fsa_currentState.final:
+			self.small_step.addCandidate(self.transition_Root_FSA_MacroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if not self.fsa_currentState.final:
+			self.small_step.addCandidate(self.transition_Root_FSA_MacroStepProcessed_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_FSA_MacroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_MacroStepProcessed):
+			return self.generateCandidatesCurrent_Root_FSA_MacroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_FSA_MacroStepProcessed_1(self, parameters):
+		self.exit_Root_FSA_MacroStepProcessed()
+		print('From FSA/MacroStepProcessed to Terminated... ')
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_Terminated()
+	
+	def transition_Root_FSA_MacroStepProcessed_2(self, parameters):
+		self.exit_Root_FSA_MacroStepProcessed()
+		print('From FSA/MacroStepProcessed to MacroStepPrepared and reading events... ')
+		self.fsa_currentEvent = self.fsa_getInputEventAt(self.fsa_logicalTime)
+		self.fsa_selectedTransition = self.fsa_model.getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+		print(self.fsa_currentEvent)
+		print(self.fsa_selectedTransition)
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MacroStepPrepared()
+	
+	def generateCandidatesCurrent_Root_FSA_MicroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if self.fsa_selectedTransition == None and False:
+			self.small_step.addCandidate(self.transition_Root_FSA_MicroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.fsa_selectedTransition == None:
+			self.small_step.addCandidate(self.transition_Root_FSA_MicroStepProcessed_2, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.fsa_selectedTransition != None:
+			self.small_step.addCandidate(self.transition_Root_FSA_MicroStepProcessed_3, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_FSA_MicroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_MicroStepProcessed):
+			return self.generateCandidatesCurrent_Root_FSA_MicroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_FSA_MicroStepProcessed_1(self, parameters):
+		self.exit_Root_FSA_MicroStepProcessed()
+		print('From FSA/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+		self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+		self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+		print(self.fsa_logicalTime)
+		print(self.fsa_elapsed)
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MacroStepProcessed()
+	
+	def transition_Root_FSA_MicroStepProcessed_2(self, parameters):
+		self.exit_Root_FSA()
+		print('From FSA/MicroStepProcessed to ChildPaused and saving outputs... ')
+		comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+		self.woven_logical_time_fsas[comp.getBlockName()] = self.fsa_logicalTime
+		self.woven_elapsed_fsas[comp.getBlockName()] = self.fsa_elapsed
+		self.woven_current_state_fsas[comp.getBlockName()] = self.fsa_currentState
+		self.woven_updateOutputFSA(self.cbd_iteration, self.fsa_logicalTime, comp, self.fsa_currentState)
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildPaused()
+	
+	def transition_Root_FSA_MicroStepProcessed_3(self, parameters):
+		self.exit_Root_FSA_MicroStepProcessed()
+		print('From FSA/MicroStepProcessed to MicroStepPrepared... ')
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MicroStepPrepared()
+	
+	def generateCandidatesCurrent_Root_FSA_MacroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_FSA_MacroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_FSA_MacroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_MacroStepPrepared):
+			return self.generateCandidatesCurrent_Root_FSA_MacroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_FSA_MacroStepPrepared_1(self, parameters):
+		self.exit_Root_FSA_MacroStepPrepared()
+		print('From FSA/MacroStepPrepared to MicroStepProcessed... ')
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_FSA_MicroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_FSA_MicroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_FSA_MicroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_FSA_MicroStepPrepared):
+			return self.generateCandidatesCurrent_Root_FSA_MicroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_FSA_MicroStepPrepared_1(self, parameters):
+		self.exit_Root_FSA_MicroStepPrepared()
+		print('From FSA/MicroStepPrepared to MicroStepProcessed and attempting to take transition... ')
+		print('Transition to be taken: ' + str(self.fsa_selectedTransition))
+		self.fsa_currentState = self.fsa_selectedTransition.target
+		self.fsa_elapsed = 0
+		self.fsa_processEvent(self.fsa_currentEvent)
+		print('New state: ' + str(self.fsa_currentState))
+		self.plotter.storeDiscreteEvent(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], self.fsa_logicalTime, self.fsa_currentState, self.fsa_selectedTransition)
+		print('Reading events:')
+		self.fsa_currentEvent = self.fsa_getInputEventAt(self.fsa_logicalTime)
+		self.fsa_selectedTransition = self.fsa_model.getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+		print(self.fsa_currentEvent)
+		print(self.fsa_selectedTransition)
+		self.combo_step.setArenaChanged(self.Root_FSA)
+		self.enter_Root_FSA_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_ParentPaused(self):
+		enabled_events = self.getEnabledEvents()
+		if not isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock):
+			self.small_step.addCandidate(self.transition_Root_ParentPaused_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock):
+			self.small_step.addCandidate(self.transition_Root_ParentPaused_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_ParentPaused(self):
+		if not self.combo_step.isArenaChanged(self.Root_ParentPaused):
+			return self.generateCandidatesCurrent_Root_ParentPaused()
+		else:
+			return True
+	
+	def transition_Root_ParentPaused_1(self, parameters):
+		self.exit_Root_ParentPaused()
+		print('From ParentPaused to ChildNotDetected...')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildNotDetected()
+	
+	def transition_Root_ParentPaused_2(self, parameters):
+		self.exit_Root_ParentPaused()
+		print('From ParentPaused to ChildDetected...')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ChildDetected()
+	
+	def generateCandidatesChildren_Root_CBD(self):
+		if self.current_state[self.Root_CBD][0] == self.Root_CBD_Terminated:
+			return self.generateCandidates_Root_CBD_Terminated()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_MacroStepPrepared:
+			return self.generateCandidates_Root_CBD_MacroStepPrepared()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_Started:
+			return self.generateCandidates_Root_CBD_Started()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_Initialized:
+			return self.generateCandidates_Root_CBD_Initialized()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_MacroStepProcessed:
+			return self.generateCandidates_Root_CBD_MacroStepProcessed()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_MicroStepPrepared:
+			return self.generateCandidates_Root_CBD_MicroStepPrepared()
+		elif self.current_state[self.Root_CBD][0] == self.Root_CBD_MicroStepProcessed:
+			return self.generateCandidates_Root_CBD_MicroStepProcessed()
+		return False
+	
+	def generateCandidates_Root_CBD(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD):
+			return self.generateCandidatesChildren_Root_CBD()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_CBD_Terminated(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_CBD_Terminated_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_CBD_Terminated(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_Terminated):
+			return self.generateCandidatesCurrent_Root_CBD_Terminated()
+		else:
+			return True
+	
+	def transition_Root_CBD_Terminated_1(self, parameters):
+		self.exit_Root_CBD()
+		print('From CBD/Terminated to HybridTerminated... ')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_HybridTerminated()
+	
+	def generateCandidatesCurrent_Root_CBD_MacroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_CBD_MacroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_CBD_MacroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_MacroStepPrepared):
+			return self.generateCandidatesCurrent_Root_CBD_MacroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_CBD_MacroStepPrepared_1(self, parameters):
+		self.exit_Root_CBD_MacroStepPrepared()
+		print('From CBD/MacroStepPrepared to MicroStepProcessed... ')
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_CBD_Started(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_CBD_Started_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_CBD_Started(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_Started):
+			return self.generateCandidatesCurrent_Root_CBD_Started()
+		else:
+			return True
+	
+	def transition_Root_CBD_Started_1(self, parameters):
+		self.exit_Root_CBD_Started()
+		print('From CBD/Started to Initialized... ')
+		self.cbd_iteration = 0
+		self.cbd_clock = 0.0
+		self.cbd_controller = CBDController(self.cbd_model, self.cbd_delta)
+		self.cbd_controller.initSimulation()
+		print('CBD clock: ' + str(self.cbd_clock))
+		print('CBD iteration: ' + str(self.cbd_iteration))
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_Initialized()
+	
+	def generateCandidatesCurrent_Root_CBD_Initialized(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_CBD_Initialized_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_CBD_Initialized(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_Initialized):
+			return self.generateCandidatesCurrent_Root_CBD_Initialized()
+		else:
+			return True
+	
+	def transition_Root_CBD_Initialized_1(self, parameters):
+		self.exit_Root_CBD_Initialized()
+		print('From CBD/Initialized to MacroStepProcessed... ')
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MacroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_CBD_MacroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if self.cbd_maxIterationsReached():
+			self.small_step.addCandidate(self.transition_Root_CBD_MacroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if not self.cbd_maxIterationsReached():
+			self.small_step.addCandidate(self.transition_Root_CBD_MacroStepProcessed_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_CBD_MacroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_MacroStepProcessed):
+			return self.generateCandidatesCurrent_Root_CBD_MacroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_CBD_MacroStepProcessed_1(self, parameters):
+		self.exit_Root_CBD_MacroStepProcessed()
+		print('From CBD/MacroStepProcessed to Terminated... ')
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_Terminated()
+	
+	def transition_Root_CBD_MacroStepProcessed_2(self, parameters):
+		self.exit_Root_CBD_MacroStepProcessed()
+		print('From CBD/MacroStepProcessed to MacroStepPrepared... ')
+		self.cbd_currentCompIdx = 0
+		self.cbd_depGraph = self.cbd_controller.createDepGraph(self.cbd_iteration)
+		self.cbd_strongComponentList = self.cbd_controller.createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MacroStepPrepared()
+	
+	def generateCandidatesCurrent_Root_CBD_MicroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_CBD_MicroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_CBD_MicroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_MicroStepPrepared):
+			return self.generateCandidatesCurrent_Root_CBD_MicroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_CBD_MicroStepPrepared_1(self, parameters):
+		self.exit_Root_CBD_MicroStepPrepared()
+		print('From CBD/MicroStepPrepared to MicroStepProcessed...')
+		self.cbd_computeBlock()
+		print('After compute block')
+		self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+		print('After cbd_currentCompIdx')
+		print('Has next:' + str(self.cbd_hasNextStrongComponent()))
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_CBD_MicroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if self.cbd_hasNextStrongComponent():
+			self.small_step.addCandidate(self.transition_Root_CBD_MicroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.cbd_hasNextStrongComponent() and False:
+			self.small_step.addCandidate(self.transition_Root_CBD_MicroStepProcessed_2, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if not self.cbd_hasNextStrongComponent():
+			self.small_step.addCandidate(self.transition_Root_CBD_MicroStepProcessed_3, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_CBD_MicroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_CBD_MicroStepProcessed):
+			return self.generateCandidatesCurrent_Root_CBD_MicroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_CBD_MicroStepProcessed_1(self, parameters):
+		self.exit_Root_CBD()
+		print('From CBD/MicroStepProcessed to ParentPaused')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ParentPaused()
+	
+	def transition_Root_CBD_MicroStepProcessed_2(self, parameters):
+		self.exit_Root_CBD_MicroStepProcessed()
+		print('From CBD/MicroStepProcessed to MicroStepPrepared')
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MicroStepPrepared()
+	
+	def transition_Root_CBD_MicroStepProcessed_3(self, parameters):
+		self.exit_Root_CBD_MicroStepProcessed()
+		print('From CBD/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+		self.plotter.store(self.cbd_iteration, self.cbd_clock, self.woven_current_state_fsas)
+		self.cbd_iteration = self.cbd_iteration + 1
+		self.cbd_clock = self.cbd_clock + self.cbd_delta
+		self.cbd_controller.advanceTimeStep()
+		print(self.cbd_clock)
+		print(self.cbd_iteration)
+		self.combo_step.setArenaChanged(self.Root_CBD)
+		self.enter_Root_CBD_MacroStepProcessed()
+	
+	# Generate transition candidates for current small step
+	def generateCandidates(self):
+		self.generateCandidates_Root()
+
+class ObjectManager(ObjectManagerBase):
+	def __init__(self, controller):
+		ObjectManagerBase.__init__(self, controller)
+	
+	def instantiate(self, class_name, construct_params):
+		if class_name == "Woven_CBD_TFSA_Simulator":
+			instance = Woven_CBD_TFSA_Simulator(self.controller, construct_params[0], construct_params[1], construct_params[2])
+			instance.associations = {}
+		return instance
+
+class Controller(ThreadsControllerBase):
+	def __init__(self, cbd_options, amodel, plotter, keep_running = None):
+		if keep_running == None: keep_running = True
+		ThreadsControllerBase.__init__(self, ObjectManager(self), keep_running)
+		self.object_manager.createInstance("Woven_CBD_TFSA_Simulator", [cbd_options, amodel, plotter])

fsa_cbd_composition/cbd_tfsa_simulator/woven_cbd_tfsa_simulator.sccd

@@ -0,0 +1,305 @@
+Diagram(name = 'Woven_CBD_FSA_Simulator_Manual',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Manually woven CBD and FSA simulators with the CBD being the dominant.'):
+    Top {
+		from CBD_Controller import CBDController
+		from cbd_tfsa_woven_classes import FSABlock
+		from cbd_tfsa_woven_classes import FSA_SemanticAdaptation
+		from fsaclasses import Events
+    }
+    Class(name = 'Woven_CBD_TFSA_Simulator', default = True):
+        Attribute(name = 'fsa_timestep')
+		Attribute(name = 'fsa_elapsed')
+		Attribute(name = 'fsa_currentState')
+		Attribute(name = 'fsa_logicalTime')
+		Attribute(name = 'fsa_currentEvent')
+		Attribute(name = 'fsa_selectedTransition')
+		Attribute(name = 'fsa_model')
+		Attribute(name = 'fsa_eventList')
+		
+		Attribute(name='cbd_clock')
+        Attribute(name='cbd_delta')
+        Attribute(name='cbd_iteration')
+        Attribute(name='cbd_depGraph')
+        Attribute(name='cbd_strongComponentList')
+        Attribute(name='cbd_currentCompIdx')
+        Attribute(name='cbd_model')
+        Attribute(name='cbd_controller')
+        Attribute(name='cbd_options')
+        
+		Attribute(name='woven_delta')
+        Attribute(name='woven_processing_fsa')
+        Attribute(name='woven_step_executed')
+        Attribute(name='woven_ended_fsa')
+        Attribute(name='woven_logical_time_fsas')
+        Attribute(name='woven_elapsed_fsas')
+        Attribute(name='woven_current_state_fsas')
+        
+		
+		Attribute(name='plotter')
+        
+		Method fsa_getInputEventAt(time) {
+			return self.fsa_eventList->getInputAt(time)
+		}
+		
+		Method cbd_maxIterationsReached() {
+			return self.cbd_iteration >= self.cbd_options->getMaxIterations()
+        }
+		
+		Method cbd_hasNextStrongComponent() {
+			return (self.cbd_currentCompIdx + 1) < len(self.cbd_strongComponentList)
+        }
+		
+		Method woven_updateEventsTriggeredByZeroCrossing(time, fsaBlock, fsaState){
+			self.fsa_eventList = Events(FSA_SemanticAdaptation->getEventsTriggeredByZeroCrossing(time, fsaBlock, fsaState))
+		}
+		
+		Method woven_updateOutputFSA(iteration, time, fsaBlock, fsaState){
+			FSA_SemanticAdaptation->updateOutputFSA(iteration, time, fsaBlock, fsaState)
+		}
+		
+		Method cbd_currentComponentIsCycle() {
+            return self.cbd_controller->componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+        }
+		
+		Constructor(cbd_options, amodel, plotter) {
+            self.cbd_options = cbd_options
+			self.cbd_delta = self.cbd_options->getDeltaT()
+			self.cbd_model = amodel
+			self.plotter = plotter
+			self.woven_processing_fsa = dict()
+			self.woven_step_executed = dict()
+			self.woven_ended_fsa = dict()
+			self.woven_logical_time_fsas = dict()
+			self.woven_elapsed_fsas = dict()
+			self.woven_current_state_fsas = dict()
+			
+			
+			self.fsa_timestep = 1.0
+        }
+		
+        StateMachine:
+            initial = 'Start'
+			State('Start'):
+				Transition(target='../CBD'):
+					Actions {
+						self.woven_delta = min(self.fsa_timestep, self.cbd_delta)
+						self.fsa_timestep = self.woven_delta
+						self.cbd_delta = self.woven_delta
+					}
+			State('CBD'):
+				initial = 'CBD_Initialize'
+				State('CBD_Initialize'):
+					OnEnter {
+						print('Enter CBD_Initialize.')
+						self.cbd_iteration = 0
+						self.cbd_clock = 0.0
+						self.cbd_controller = CBDController(self.cbd_model,self.cbd_delta)
+						self.cbd_controller->initSimulation()
+						print("CBD clock: " + str(self.cbd_clock))
+						print("CBD iteration: " + str(self.cbd_iteration))
+					}
+					Transition(target='../CBD_CheckTerminationCondition'):
+						Actions {
+							print('Going to CBD_CheckTerminationCondition.')
+						}
+				State('CBD_CheckTerminationCondition'):
+					OnEnter {
+						print('Enter CBD_CheckTerminationCondition.')
+					}
+					Transition(target='../CBD_Initialize_Step'):
+						guard = {not self->cbd_maxIterationsReached()}
+						Actions {
+							print('Going to CBD_Initialize_Step')
+						}
+					Transition(target='../CBD_SimulationComplete'):
+						guard = {self->cbd_maxIterationsReached()}
+						Actions {
+							print('Going to CBD_SimulationComplete')
+						}
+				State('CBD_Initialize_Step'):
+					OnEnter {
+						print('Enter CBD_Initialize_Step.')
+						self.cbd_depGraph = self.cbd_controller->createDepGraph(self.cbd_iteration)
+						self.cbd_strongComponentList = self.cbd_controller->createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+					}
+					Transition(target='../CBD_CheckNextComponent'):
+						Actions {
+							print('Going to CBD_CheckNextComponent')
+							self.cbd_currentCompIdx = -1
+						}
+				State('CBD_CheckNextComponent'):
+					OnEnter {
+						print('Enter CBD_CheckNextComponent.')
+					}
+					Transition(target='../CBD_CheckCycle'):
+						guard = {self->cbd_hasNextStrongComponent()}
+						Actions {
+							self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+							print('Going to CBD_CheckCycle: ' + str(self.cbd_strongComponentList[self.cbd_currentCompIdx]))
+						}
+					Transition(target='../CBD_CheckTerminationCondition'):
+						guard = {not self->cbd_hasNextStrongComponent()}
+						Actions {
+							self.plotter->store(self.cbd_iteration, self.cbd_clock, self.woven_current_state_fsas)
+							self.cbd_iteration = self.cbd_iteration + 1
+							self.cbd_clock = self.cbd_clock + self.cbd_delta
+							self.cbd_controller->advanceTimeStep()
+							print("CBD clock: " + str(self.cbd_clock))
+							print("CBD iteration: " + str(self.cbd_iteration))	
+							print('Going to CBD_CheckTerminationCondition')
+						}
+				State('CBD_CheckCycle'):
+					OnEnter {
+						print('Enter CBD_CheckCycle.')
+					}
+					Transition(target='../CBD_CheckNextComponent'):
+						guard = {self->cbd_currentComponentIsCycle() and not isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock)}
+						Actions {
+							print('Going to CBD_CheckNextComponent via algebraic loop')
+							self.cbd_controller->computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					Transition(target='../CBD_CheckNextComponent'):
+						guard = {not self->cbd_currentComponentIsCycle() and not isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock)}
+						Actions {
+							print('Going to CBD_CheckNextComponent via atomic block')
+							self.cbd_controller->computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					Transition(target='../../ProcessFSA'):
+						guard = {isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock)}
+						Actions {
+							print('Going to ProcessFSA')
+							self.woven_step_executed[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] = False
+						}
+				State('CBD_SimulationComplete'):
+					OnEnter {
+						print('Enter CBD_SimulationComplete.')
+					}
+			State('ProcessFSA'):
+				OnEnter {
+					print('Enter ProcessFSA.')
+					if not self.woven_step_executed->has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()):
+						self.woven_step_executed[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] = False
+					end
+					if not self.woven_processing_fsa->has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()):
+						self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] = False
+					end
+					if not self.woven_ended_fsa->has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()):
+						self.woven_ended_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] = False
+					end
+				}
+				Transition(target='../CBD/CBD_CheckNextComponent'):
+					guard = {self.woven_step_executed[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()]}
+					Actions {
+						print('Going to CBD_CheckNextComponent')
+					}
+				Transition(target='../FSA'):
+					guard = {not self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] and not self.woven_step_executed[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] and not self.woven_ended_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()]}
+					Actions {
+						print('Going to FSA')
+						comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+						self.fsa_model = comp.fsa
+						self->woven_updateEventsTriggeredByZeroCrossing(self.cbd_clock, comp, comp.fsa.initialState)
+					}
+				Transition(target='../FSA/FSA_Check'):
+					guard = {self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] and not self.woven_step_executed[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] and not self.woven_ended_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()]}
+					Actions {
+						print('Going to FSA_Check')
+						comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+						self.fsa_logicalTime = self.woven_logical_time_fsas[comp->getBlockName()]
+						self.fsa_elapsed = self.woven_elapsed_fsas[comp->getBlockName()]
+						self.fsa_currentState = self.woven_current_state_fsas[comp->getBlockName()]
+						self.fsa_model = comp.fsa
+						
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						
+						self->woven_updateEventsTriggeredByZeroCrossing(self.fsa_logicalTime, comp, self.fsa_currentState)
+					}
+			State('FSA'):
+				OnEnter {
+					print('Enter FSA.')
+				}
+				initial = 'FSA_Start'
+				State('FSA_Start'):
+					OnEnter {
+						print('Enter FSA_Start.')
+					}
+					Transition(target='../FSA_Check'):
+						Actions {
+							print('Going to FSA_Check')
+							self.fsa_logicalTime = 0.0
+							self.fsa_elapsed = 0
+							self.fsa_timestep = self.woven_delta
+							self.fsa_currentState = self.fsa_model.initialState
+						}
+				State('FSA_Check'):
+					OnEnter {
+						print('Enter FSA_Check.')
+						self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+						self.fsa_selectedTransition = self.fsa_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+						
+						print("Read event: " + str(self.fsa_currentEvent))
+						print("Selected transition: " + str(self.fsa_selectedTransition))
+					}
+					Transition(target='../FSA_End'):
+						guard = {self.fsa_currentState.final}
+						Actions {
+							print('Going to FSA_End')
+						}
+					Transition(target='../FSA_Processing'):
+						guard = {not self.fsa_currentState.final}
+						Actions {
+							print('Going to FSA_Processing')
+						}
+				State('FSA_Processing'):
+					OnEnter {
+						print('Enter FSA_Processing.')
+					}
+					Transition(target='../FSA_Check'):
+						guard = {self.fsa_selectedTransition != None}
+						Actions {
+							self.fsa_currentState = self.fsa_selectedTransition.target
+							self.fsa_elapsed = 0
+							
+							self.plotter->storeDiscreteEvent(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+						
+							
+							print("changing to state: ")
+							print(self.fsa_currentState->getName())
+							print(self.fsa_logicalTime)
+							print(self.fsa_elapsed)
+						}
+					Transition(target='../../ProcessFSA'):
+						guard = {self.fsa_selectedTransition == None}
+						Actions {
+							print('Going to ProcessFSA')
+							
+							comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+							self.woven_logical_time_fsas[comp->getBlockName()] = self.fsa_logicalTime
+							self.woven_elapsed_fsas[comp->getBlockName()] = self.fsa_elapsed
+							self.woven_current_state_fsas[comp->getBlockName()] = self.fsa_currentState
+							
+							
+							self->woven_updateOutputFSA(self.cbd_iteration, self.fsa_logicalTime, comp, self.fsa_currentState)
+							self.woven_processing_fsa[comp->getBlockName()] = True
+							self.woven_step_executed[comp->getBlockName()] = True
+							
+						}
+				State('FSA_End'):
+					OnEnter {
+						print('Enter FSA_End.')
+					}
+					Transition(target='../../FSA'):
+						Actions {
+							print('Going to FSA')
+							comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+							self.woven_ended_fsa[comp->getBlockName()] = True
+							
+							self->woven_updateOutputFSA(self.cbd_iteration, self.fsa_logicalTime, comp, self.fsa_currentState)
+							
+							self.woven_processing_fsa[comp->getBlockName()] = True
+							self.woven_step_executed[comp->getBlockName()] = True
+							
+						}
+				

fsa_cbd_composition/cbd_tfsa_simulator/woven_cbd_tfsa_simulator_normal.sccd

@@ -0,0 +1,315 @@
+Diagram(name = 'Woven_CBD_FSA_Simulator_Automatic',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Automatically woven CBD and FSA simulators with the CBD being the dominant.'):
+    Top {
+		from CBD_Controller import CBDController
+		from cbd_tfsa_woven_classes import FSABlock
+		from cbd_tfsa_woven_classes import FSA_SemanticAdaptation
+		from fsaclasses import Events
+    }
+    Class(name = 'Woven_CBD_TFSA_Simulator', default = True):
+        Attribute(name = 'fsa_timestep')
+		Attribute(name = 'fsa_elapsed')
+		Attribute(name = 'fsa_currentState')
+		Attribute(name = 'fsa_logicalTime')
+		Attribute(name = 'fsa_currentEvent')
+		Attribute(name = 'fsa_selectedTransition')
+		Attribute(name = 'fsa_model')
+		Attribute(name = 'fsa_eventList')
+		
+		Attribute(name='cbd_clock')
+        Attribute(name='cbd_delta')
+        Attribute(name='cbd_iteration')
+        Attribute(name='cbd_depGraph')
+        Attribute(name='cbd_strongComponentList')
+        Attribute(name='cbd_currentCompIdx')
+        Attribute(name='cbd_model')
+        Attribute(name='cbd_controller')
+        Attribute(name='cbd_options')
+        
+		Attribute(name='woven_delta')
+        Attribute(name='woven_processing_fsa')
+        Attribute(name='woven_step_executed')
+        Attribute(name='woven_ended_fsa')
+        Attribute(name='woven_logical_time_fsas')
+        Attribute(name='woven_elapsed_fsas')
+        Attribute(name='woven_current_state_fsas')
+        
+		Attribute(name='plotter')
+        
+		Method fsa_getInputEventAt(time) {
+			return self.fsa_eventList->getInputAt(time)
+		}
+		
+		Method fsa_processEvent(event) {
+			if (event != None):
+				self.fsa_eventList->popEvent(event)
+				event.processed = True
+			end
+		}
+		
+		Method cbd_computeBlock(){
+			if self->cbd_currentComponentIsCycle():
+				self.cbd_controller->computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+			else:
+				self.cbd_controller->computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+			end
+		}
+		
+		Method cbd_maxIterationsReached() {
+			return self.cbd_iteration >= self.cbd_options->getMaxIterations()
+        }
+		
+		Method cbd_hasNextStrongComponent() {
+			return self.cbd_currentCompIdx < len(self.cbd_strongComponentList)
+        }
+		
+		Method woven_updateEventsTriggeredByZeroCrossing(time, fsaBlock, fsaState){
+			self.fsa_eventList = Events(FSA_SemanticAdaptation->getEventsTriggeredByZeroCrossing(time, fsaBlock, fsaState))
+		}
+		
+		Method woven_updateOutputFSA(iteration, time, fsaBlock, fsaState){
+			FSA_SemanticAdaptation->updateOutputFSA(iteration, time, fsaBlock, fsaState)
+		}
+		
+		Method cbd_currentComponentIsCycle() {
+            return self.cbd_controller->componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+        }
+		
+		Constructor(cbd_options, amodel, plotter) {
+            self.cbd_options = cbd_options
+			self.cbd_delta = self.cbd_options->getDeltaT()
+			self.cbd_model = amodel
+			self.plotter = plotter
+			self.woven_processing_fsa = dict()
+			self.woven_step_executed = dict()
+			self.woven_ended_fsa = dict()
+			self.woven_logical_time_fsas = dict()
+			self.woven_elapsed_fsas = dict()
+			self.woven_current_state_fsas = dict()
+			
+			self.fsa_timestep = 1.0
+        }
+		
+        StateMachine:
+            initial = 'CBD'
+			final = 'HybridTerminated'
+			State('CBD'):
+				initial = 'Started'
+				State('Started'):
+					Transition(target='../Initialized'):
+						Actions {
+							print('From CBD/Started to Initialized... ')
+							self.cbd_iteration = 0
+							self.cbd_clock = 0.0
+							self.cbd_controller = CBDController(self.cbd_model,self.cbd_delta)
+							self.cbd_controller->initSimulation()
+							print("CBD clock: " + str(self.cbd_clock))
+							print("CBD iteration: " + str(self.cbd_iteration))
+						}
+				State('Initialized'):
+					Transition(target='../MacroStepProcessed'):
+						Actions {
+							print('From CBD/Initialized to MacroStepProcessed... ')
+						}
+				State('MacroStepProcessed'):
+					Transition(target='../MacroStepPrepared'):
+						guard = { not self->cbd_maxIterationsReached() }
+						Actions {
+							print('From CBD/MacroStepProcessed to MacroStepPrepared... ')
+							self.cbd_currentCompIdx = 0
+							self.cbd_depGraph = self.cbd_controller->createDepGraph(self.cbd_iteration)
+							self.cbd_strongComponentList = self.cbd_controller->createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+						}
+					Transition(target='../Terminated'):
+						guard = { self->cbd_maxIterationsReached() }
+						Actions {
+							print('From CBD/MacroStepProcessed to Terminated... ')
+						}
+				State('MacroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From CBD/MacroStepPrepared to MicroStepProcessed... ')
+						}
+				State('MicroStepProcessed'):
+					Transition(target='../MacroStepProcessed'):
+						guard = { not self->cbd_hasNextStrongComponent() }
+						Actions {
+							print('From CBD/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+							self.plotter->store(self.cbd_iteration, self.cbd_clock, self.woven_current_state_fsas)
+							self.cbd_iteration = self.cbd_iteration + 1
+							self.cbd_clock = self.cbd_clock + self.cbd_delta
+							self.cbd_controller->advanceTimeStep()
+							print(self.cbd_clock)
+							print(self.cbd_iteration)
+						}
+					Transition(target='../MicroStepPrepared'):
+						guard = { self->cbd_hasNextStrongComponent() and False }
+						Actions {
+							print('From CBD/MicroStepProcessed to MicroStepPrepared')
+						}
+					Transition(target='../../ParentPaused'):
+						guard = { self->cbd_hasNextStrongComponent() }
+						Actions {
+							print('From CBD/MicroStepProcessed to ParentPaused')
+						}
+				State('MicroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From CBD/MicroStepPrepared to MicroStepProcessed...')
+							self->cbd_computeBlock()
+							print('After compute block')
+							self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+							print('After cbd_currentCompIdx')
+							print('Has next:' + str(self->cbd_hasNextStrongComponent()))
+						}
+				State('Terminated'):
+					Transition(target='../../HybridTerminated'):
+						Actions {
+							print('From CBD/Terminated to HybridTerminated... ')
+						}
+			State('HybridTerminated')
+			State('ChildNotInitialized'):
+				Transition(target='../FSA/Started'):
+					Actions {
+						print('From ChildNotInitialized to CBD/Started... ')
+						comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+						self.fsa_model = comp.fsa
+						self->woven_updateEventsTriggeredByZeroCrossing(self.cbd_clock, comp, comp.fsa.initialState)
+						self.woven_processing_fsa[comp->getBlockName()] = True
+					}
+			State('ChildInitialized'):
+				Transition(target='../FSA/MacroStepProcessed'):
+					Actions {
+						print('From ChildInitialized to CBD/MacroStepProcessed... ')
+						comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+						self.fsa_logicalTime = self.woven_logical_time_fsas[comp->getBlockName()]
+						self.fsa_elapsed = self.woven_elapsed_fsas[comp->getBlockName()]
+						self.fsa_currentState = self.woven_current_state_fsas[comp->getBlockName()]
+						self.fsa_model = comp.fsa
+						
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						
+						self->woven_updateEventsTriggeredByZeroCrossing(self.fsa_logicalTime, comp, self.fsa_currentState)
+					}
+			State('ChildPaused'):
+				Transition(target='../ChildProcessed'):
+					Actions {
+						print('From ChildPaused to ChildProcessed...')
+					}
+			State('ChildProcessed'):
+				Transition(target='../CBD/MicroStepProcessed'):
+					Actions {
+						print('From ChildProcessed to CBD/MicroStepProcessed and incrementing cbd_currentCompIdx...')
+						self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+					}
+			State('ChildNotDetected'):
+				Transition(target='../CBD/MicroStepPrepared'):
+					Actions {
+						print('From ChildProcessed to CBD/MicroStepPrepared...')
+					}
+			State('ParentPaused'):
+				Transition(target='../ChildNotDetected'):
+					guard = { not isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock) }
+					Actions {
+						print('From ParentPaused to ChildNotDetected...')
+					}
+				Transition(target='../ChildDetected'):
+					guard = { isinstance(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], FSABlock) }
+					Actions {
+						print('From ParentPaused to ChildDetected...')
+					}
+			State('ChildDetected'):
+				Transition(target='../ChildNotInitialized'):
+					guard = { not self.woven_processing_fsa->has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()) or not self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] }
+				Transition(target='../ChildInitialized'):
+					guard = { self.woven_processing_fsa->has_key(self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()) and self.woven_processing_fsa[self.cbd_strongComponentList[self.cbd_currentCompIdx][0]->getBlockName()] }
+			State('FSA'):
+				initial = 'Started'
+				State('Started'):
+					Transition(target='../Initialized'):
+						Actions {
+							print('From FSA/Started to Initialized... ')
+							self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+							self.fsa_logicalTime = 0.0
+							self.fsa_elapsed = 0
+							self.fsa_timestep = self.weaved_delta
+							self.fsa_currentState = self.fsa_model.initialState
+						}
+				State('Initialized'):
+					Transition(target='../MacroStepProcessed'):
+						Actions {
+							print('From FSA/Initialized to MacroStepProcessed... ')
+						}
+				State('MacroStepProcessed'):
+					Transition(target='../MacroStepPrepared'):
+						guard = { not self.fsa_currentState.final }
+						Actions {
+							print('From FSA/MacroStepProcessed to MacroStepPrepared and reading events... ')
+							self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+							self.fsa_selectedTransition = self.fsa_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+							print(self.fsa_currentEvent)
+							print(self.fsa_selectedTransition)
+						}
+					Transition(target='../Terminated'):
+						guard = { self.fsa_currentState.final }
+						Actions {
+							print('From FSA/MacroStepProcessed to Terminated... ')
+						}
+				State('MacroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From FSA/MacroStepPrepared to MicroStepProcessed... ')
+						}
+				State('MicroStepProcessed'):
+					Transition(target='../MacroStepProcessed'):
+						guard = { self.fsa_selectedTransition == None and False}
+						Actions {
+							print('From FSA/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+							self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+							self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+							print(self.fsa_logicalTime)
+							print(self.fsa_elapsed)
+						}
+					Transition(target='../MicroStepPrepared'):
+						guard = { self.fsa_selectedTransition != None }
+						Actions {
+							print('From FSA/MicroStepProcessed to MicroStepPrepared... ')
+						}
+					Transition(target='../../ChildPaused'):
+						guard = { self.fsa_selectedTransition == None }
+						Actions {
+							print('From FSA/MicroStepProcessed to ChildPaused and saving outputs... ')
+							comp = self.cbd_strongComponentList[self.cbd_currentCompIdx][0]
+							self.woven_logical_time_fsas[comp->getBlockName()] = self.fsa_logicalTime
+							self.woven_elapsed_fsas[comp->getBlockName()] = self.fsa_elapsed
+							self.woven_current_state_fsas[comp->getBlockName()] = self.fsa_currentState
+							
+							self->woven_updateOutputFSA(self.cbd_iteration, self.fsa_logicalTime, comp, self.fsa_currentState)
+						}
+				State('MicroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From FSA/MicroStepPrepared to MicroStepProcessed and attempting to take transition... ')
+							print('Transition to be taken: ' + str(self.fsa_selectedTransition))
+							self.fsa_currentState = self.fsa_selectedTransition.target
+							self.fsa_elapsed = 0
+							self->fsa_processEvent(self.fsa_currentEvent)
+							print('New state: ' + str(self.fsa_currentState))
+							
+							self.plotter->storeDiscreteEvent(self.cbd_strongComponentList[self.cbd_currentCompIdx][0], self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+							
+							print('Reading events:')
+							self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+							self.fsa_selectedTransition = self.fsa_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+							print(self.fsa_currentEvent)
+							print(self.fsa_selectedTransition)
+						}
+				State('Terminated'):
+					Transition(target='../../HybridTerminated'):
+						Actions {
+							print('From FSA/Terminated to HybridTerminated... ')
+						}
+				
+		

fsa_cbd_composition/cbd_tfsa_simulator/woven_runner.py

@@ -0,0 +1,22 @@
+'''
+@author: Claudio Gomes and Bruno Barroca
+'''
+
+from Options import Options
+import os
+from woven_cbd_tfsa_lib import CBDFSAPlotter
+from models.powerwindow import PowerWindowCBD
+from woven_cbd_tfsa_simulator import Controller
+
+CBD_DELTA = 0.01
+
+if __name__ == '__main__':
+    
+    options = Options(delta = CBD_DELTA)
+    options.setMaxIterations(int(10 / CBD_DELTA));
+    cbdmodel = PowerWindowCBD("powerwindow", CBD_DELTA)
+    plotter = CBDFSAPlotter(cbdmodel)
+    controller = Controller(options, cbdmodel, plotter, keep_running=False)
+    controller.start()
+    controller.join()
+    

fsa_cbd_composition/cbdsimulator/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>cbdsimulator</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

fsa_cbd_composition/cbdsimulator/.pydevproject

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+<path>/${PROJECT_DIR_NAME}</path>
+</pydev_pathproperty>
+<pydev_pathproperty name="org.python.pydev.PROJECT_EXTERNAL_SOURCE_PATH">
+<path>C:\Users\clagms\Source Control\SVN_SCCD</path>
+</pydev_pathproperty>
+</pydev_project>

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Source/CBD.py

@@ -0,0 +1,885 @@
+import math
+import naivelog
+from collections import namedtuple
+
+InputLink = namedtuple("InputLink", ["block", "output_port"])
+Signal = namedtuple("Signal", ["time", "value"])
+def enum(**enums):
+            return type('Enum', (), enums)
+level = enum(WARNING=1, ERROR=2, FATAL=3)	
+epsilon = 0.001		
+
+class BaseBlock:
+    """
+    A base class for all types of basic blocks
+    """
+    def __init__(self, name, input_ports, output_ports):
+        self.setBlockName(name)
+
+        #The output signals produced by this block is encoded as a dictionary.
+        #The key of this dictionary is the name of the output port.
+        #Each element of the dictionary contains an ordered list of values.
+        self.__signals = dict()
+        for output_port in output_ports:
+            self.__signals[output_port] = []
+        
+        self._output_ports = output_ports
+        
+        #The input links produced by this block is encoded as a dictionary.
+        #The key of this dictionary is the name of the input port.
+        #Each element of the dictionary contains
+        #an tuple of the block and the output name of the other block.
+        self._linksIn = dict()
+
+        #The list of possible input ports
+        self.__nameLinks = input_ports
+        #In wich CBD the baseblock is situated
+        self._parent = None
+    
+    def getOutputPorts(self):
+        return self._output_ports
+    
+    def resetSignals(self):
+        for output_port in self.__signals:
+            self.__signals[output_port] = []
+    
+    def getBlockName(self):
+        return self.__block_name
+
+    def setBlockName(self, block_name):
+        self.__block_name = block_name
+
+    def setParent(self, parent):
+        self._parent = parent
+
+    def getBlockType(self):
+        return self.__class__.__name__
+
+    def getLinksIn(self):
+        return self._linksIn
+
+    def getOutputNameOfInput(self, inputBlock):
+        return [ y for (x,y) in self._linksIn.iteritems() if y.block == inputBlock ][0].output_port
+
+    def getInputName(self, inputBlock):
+        return [ x for (x,y) in self._linksIn.iteritems() if y.block == inputBlock ]
+
+    def getClock(self):
+        return self._parent.getClock()
+
+    def appendToSignal(self, value, name_output = None):
+        name_output = "OUT1" if name_output == None else name_output
+        assert name_output in self.__signals.keys()
+        self.__signals[name_output].append(Signal(self.getClock().getTime(), value))
+
+    def getSignal(self, name_output = None):
+        name_output = "OUT1" if name_output == None else name_output
+        assert name_output in self.__signals.keys()
+        return self.__signals[name_output] if name_output != None else self.__signals["OUT1"]
+
+    def getDependencies(self, curIteration):
+        return list(set([ tup.block for tup in self._linksIn.values() ]))
+
+    def getBlockConnectedToInput(self, input_port):
+        return self._linksIn[input_port]
+
+    def getInputSignal(self, curIteration, input_port = None):
+        """
+        Returns the signal sent out by the input block (IN1 if none given,
+        at the last time if no curIteration is given).
+        """
+        input_port = "IN1" if input_port == None else input_port
+        curIteration = -1 if curIteration == None else curIteration
+
+        (incoming_block, out_port_name) = self._linksIn[input_port]
+        return incoming_block.getSignal(out_port_name)[curIteration]
+
+    def compute(self, curIteration):
+        exit("BaseBlock has nothing to compute")
+
+    def linkInput(self, in_block, name_input, name_output):
+        """
+        linkInput will link the output of the from_block to the input of the to_block
+        -if no name_input was given for the to_block, we will derive the right input,
+        by checking which input IN has nothing connected to it yet
+        -if no name_output was given we use the first OUT output
+        """
+        name_output = "OUT1" if name_output == None else name_output
+        if name_input != None:
+            assert name_input in self.__nameLinks
+            self._linksIn[name_input] = InputLink(in_block, name_output)
+        else:
+            i = 1
+            while True:
+                nextIn = "IN" + str(i)
+                if nextIn in self.__nameLinks:
+                    if not nextIn in self._linksIn:
+                        self._linksIn[nextIn] = InputLink(in_block, name_output)
+                        return
+                else:
+                    exit("There are no open IN inputs left in block %s" % self.getBlockName())
+                i += 1
+
+    def __repr__(self):
+        repr = self.getBlockName() + ":" + self.getBlockType() + "\n"
+        if len(self._linksIn) == 0:
+            repr+= "  No incoming connections to IN ports\n"
+        else:
+            for (key, (in_block, out_port)) in self._linksIn.iteritems():
+                repr += "In input " + key + ":  IN <- " + in_block.getBlockName() + ":" + in_block.getBlockType() + "\n"
+        return repr
+
+class ConstantBlock(BaseBlock):
+    """
+    The constant block will always output its constant value
+    """
+    def __init__(self, block_name, value=0.0):
+        BaseBlock.__init__(self, block_name, [], ["OUT1"])
+        self.__value = value
+
+    def getValue(self):
+        return self.__value
+
+    def setValue(self, value):
+        self.__value = value
+
+    def compute(self, curIteration):
+        self.appendToSignal(self.getValue())
+
+    def __repr__(self):
+        return BaseBlock.__repr__(self) + "  Value = " + str(self.getValue()) + "\n"
+
+class NegatorBlock(BaseBlock):
+    """
+    The negator block will output the value of the input multiplied with -1
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(-self.getInputSignal(curIteration).value)
+
+class InverterBlock(BaseBlock):
+    """
+    The invertblock will output 1/IN
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(1.0/self.getInputSignal(curIteration).value)
+
+class AdderBlock(BaseBlock):
+    """
+    The adderblock will add the 2 inputs
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.getInputSignal(curIteration, "IN1").value + self.getInputSignal(curIteration, "IN2").value)
+
+class ProductBlock(BaseBlock):
+    """
+    The product block will multiply the two inputs
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.getInputSignal(curIteration, "IN1").value * self.getInputSignal(curIteration, "IN2").value)
+
+class GenericBlock(BaseBlock):
+    """
+    The generic block will evaluate the operator on the input
+    operator is the name (a string) of a Python function from the math library
+    which will be called when the block is evaluated
+    by default, initialized to None
+    """
+    def __init__(self, block_name, block_operator=None):
+        # operator is the name (a string) of a Python function from the math library
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+        self.__block_operator = block_operator
+
+    def getBlockOperator(self):
+        return self.__block_operator
+
+    def compute(self, curIteration):
+        operator = getattr(math, self.getBlockOperator())
+        self.appendToSignal(operator(self.getInputSignal(curIteration).value))
+
+    def __repr__(self):
+        repr = BaseBlock.__repr__(self)
+        if self.__block_operator == None:
+            repr += "  No operator given\n"
+        else:
+            repr += "  Operator :: " + self.__block_operator + "\n"
+        return repr
+
+class RootBlock(BaseBlock):
+    """
+    A basic block that computes the IN2-th root from IN1
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(pow(self.getInputSignal(curIteration, "IN1").value, 1.0/self.getInputSignal(curIteration, "IN2").value))
+
+class ModuloBlock(BaseBlock):
+    """
+    A basic block that computes the IN1 modulo IN3
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1", "IN2"], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(math.fmod(self.getInputSignal(curIteration, "IN1").value, self.getInputSignal(curIteration, "IN2").value))
+
+class DelayBlock(BaseBlock):
+    """
+    A delay block that takes the last value from the list
+    IC: Initial Condition
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1", "IC"], ["OUT1"])
+        self.__values = []
+
+    def getDependencies(self, curIteration):
+        if curIteration == 0:
+            return [self._linksIn["IC"].block]
+        return []
+    
+    def resetSignals(self):
+        BaseBlock.resetSignals(self)
+        self.__values = []
+    
+    def compute(self, curIteration):
+        if curIteration == 0:
+            outputValue = self.getInputSignal(curIteration, "IC")
+            self.appendToSignal(outputValue.value)
+        else:
+            assert curIteration == len(self.__values)+1
+            (incoming_block, out_port_name) = self._linksIn["IN1"]
+            self.__values.append(incoming_block.getSignal(out_port_name)[curIteration-1])
+            self.appendToSignal(self.__values[curIteration-1].value)
+    
+class InputPortBlock(BaseBlock):
+    """
+    The input port of a CBD
+    """
+    def __init__(self, block_name, parent):
+        BaseBlock.__init__(self, block_name, [], ["OUT1"])
+        self.parent = parent
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.parent.getInputSignal(curIteration, self.getBlockName()).value)
+
+class OutputPortBlock(BaseBlock):
+    """
+    The output port of a CBD
+    """
+    def __init__(self, block_name, parent):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+        self.parent = parent
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.getInputSignal(curIteration, "IN1").value)
+
+class WireBlock(BaseBlock):
+    """
+    When a CBD gets flattened, the port blocks will be replaced by a wire block
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.getInputSignal(curIteration, "IN1").value)
+
+class TimeBlock(BaseBlock):
+    """
+    Outputs the current time of the simulation
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, [], ["OUT1"])
+
+    def	compute(self, curIteration):
+        self.appendToSignal(self.getClock().getTime())
+
+class LessThanBlock(BaseBlock):
+    """
+    A simple block that will test if the IN1 is smaller than IC (output == 1 if true else 0)
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IC", "IN1"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        gisv = lambda s: self.getInputSignal(curIteration, s).value
+        self.appendToSignal(1 if gisv("IN1") < gisv("IC") else 0)
+
+class EqualsBlock(BaseBlock):
+    """
+    A simple block that will test if the IN1 is equal to IC (output == 1 if true else 0)
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IC", "IN1"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        gisv = lambda s: self.getInputSignal(curIteration, s).value
+        self.appendToSignal(1 if gisv("IN1") == gisv("IC") else 0)
+
+class NotBlock(BaseBlock):
+    """
+    A simple Not block that will set a 0 to 1 and vice versa
+    """
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+
+    def	compute(self, curIteration):
+        result = 0 if self.getInputSignal(curIteration, "IN1").value else 1
+        self.appendToSignal(result)    
+
+class OrBlock(BaseBlock):
+    """
+    A simple Or block with possibly multiple inputlines
+    """
+    def __init__(self, block_name, numberOfInputs=2):
+        BaseBlock.__init__(self, block_name, ["IN{0}".format(i) for i in xrange(1,numberOfInputs+1)], ["OUT1"])
+        self.__numberOfInputs = numberOfInputs
+
+    def	compute(self, curIteration):
+        result = 0
+        for i in xrange(1, self.__numberOfInputs+1):
+            result = result or self.getInputSignal(curIteration, "IN"+str(i)).value
+        self.appendToSignal(result)    
+
+class AndBlock(BaseBlock):
+    """
+    A simple And block with possibly multiple inputlines
+    """
+    def __init__(self, block_name, numberOfInputs=2):
+        BaseBlock.__init__(self, block_name, ["IN{0}".format(i) for i in xrange(1,numberOfInputs+1)], ["OUT1"])
+        self.__numberOfInputs = numberOfInputs
+
+    def	compute(self, curIteration):
+        result = 1
+        for i in xrange(1, self.__numberOfInputs+1):
+            result = result and self.getInputSignal(curIteration, "IN"+str(i)).value
+        self.appendToSignal(result)
+
+class SequenceBlock(BaseBlock):
+    """
+    A simple Sequence block: block initializes signal input with given sequence
+    Use only for the tests please
+    """
+    def __init__(self, block_name, sequence):
+        BaseBlock.__init__(self, block_name, [], ["OUT1"])
+        self.__sequence = sequence
+
+    def	compute(self, curIteration):
+        if len(self.__sequence) < curIteration:
+            self.__logger.fatal("Sequence is not long enough")
+        self.appendToSignal(self.__sequence[curIteration])
+
+class LoggingBlock(BaseBlock):
+    """
+    A simple Logging block
+    """
+    def __init__(self, block_name, string, lev = level.WARNING):
+        BaseBlock.__init__(self, block_name, ["IN1"], [])
+        self.__string = string
+        self.__logger = naivelog.getLogger("WarningLog")
+        self.__lev = lev
+
+    def	compute(self, curIteration):
+        if self.getInputSignal(curIteration, "IN1").value == 1:
+            if self.__lev == level.WARNING:
+                self.__logger.warning("Time " + str(self.getClock().getTime()) + ": " + self.__string)
+            elif self.__lev == level.ERROR:
+                self.__logger.error("Time " + str(self.getClock().getTime()) + ": " + self.__string)
+            elif self.__lev == level.FATAL:
+                self.__logger.fatal("Time " + str(self.getClock().getTime()) + ": " + self.__string)
+
+class Clock:
+    """
+    The clock of the simulation
+    delta_t is the timestep of the simulation
+    """
+    def __init__(self, delta_t):
+        self.__delta_t = delta_t
+        self.__time = 0.0
+
+    def getTime(self):
+        return self.__time
+
+    def step(self):
+        self.__time = self.__time + self.__delta_t
+
+    def setDeltaT(self, new_delta_t):
+        self.__delta_t = new_delta_t
+
+    def getDeltaT(self):
+        return self.__delta_t
+
+class CBD(BaseBlock):
+    """
+    The CBD class, contains an entire Causal Block Diagram
+    Call the run function to simulate the model.
+    """
+    def __init__(self, block_name, input_ports = None, output_ports = None):
+        input_ports = input_ports if input_ports != None else []
+        output_ports = output_ports if output_ports != None else []
+        BaseBlock.__init__(self, block_name, input_ports, output_ports)
+        #The blocks in the CBD will be stored both
+        #-as an ordered list __blocks and
+        #-as a dictionary __blocksDict with the blocknames as keys
+        #for fast name-based retrieval and to ensure block names are unique within a single CBD
+        self.__blocks = []
+        self.__blocksDict = {}
+        self.__clock = None
+        self.__deltaT = None
+        self.__logger = naivelog.getLogger("CBD")
+
+        for input_port in input_ports:
+            self.addBlock(InputPortBlock(input_port, self))
+
+        for output_port in output_ports:
+            self.addBlock(OutputPortBlock(output_port, self))
+
+    def getTopCBD(self):
+        return self if self._parent == None else self._parent.getTopCBD()
+
+    def setBlocks(self, blocks):
+        # blocks must be a list of BaseBlock (subclass) instances
+        assert type(blocks) == list, ("CBD.setBlocks() takes a list as argument, not a %s" % type(blocks))
+        for block in blocks:
+            assert isinstance(block, BaseBlock), "CBD.setBlocks() takes a list of BaseBlock (subclass) instances"
+
+    def getBlocks(self):
+        return self.__blocks
+
+    def getBlockByName(self, name):
+        return self.__blocksDict[name]
+    
+    def setClock(self, clock):
+        self.__clock = clock;
+    
+    def getClock(self):
+        return self.__clock if self._parent == None else self._parent.getClock()
+
+    def setDeltaT(self, deltaT):
+        self.__deltaT = deltaT
+
+    def addBlock(self, block):
+        """
+        Add a block to the CBD model
+        """
+        assert isinstance(block, BaseBlock), "Can only add BaseBlock (subclass) instances to a CBD"
+        block.setParent(self)
+
+        if not self.__blocksDict.has_key(block.getBlockName()):
+            self.__blocks.append(block)
+            self.__blocksDict[block.getBlockName()] = block
+        else:
+            print("Warning: did not add this block as it has the same name %s as an existing block" % block.getBlockName())
+
+    def removeBlock(self, block):
+        assert isinstance(block, BaseBlock), "Can only delete BaseBlock (subclass) instances to a CBD"
+
+        if self.__blocksDict.has_key(block.getBlockName()):
+            self.__blocks.remove(block)
+            del self.__blocksDict[block.getBlockName()]
+        else:
+            exit("Warning: did not remove this block %s as it was not found" % block.getBlockName())
+
+    def addConnection(self, from_block, to_block, input_port_name = None, output_port_name = None):
+        """
+        Add a connection between from_block with input_port_name to to_block with outport_port_name
+        """
+        if type(from_block) == str:
+            from_block = self.getBlockByName(from_block)
+        if type(to_block) == str:
+            to_block = self.getBlockByName(to_block)
+        to_block.linkInput(from_block, input_port_name, output_port_name)
+
+    def __repr__(self):
+        repr = BaseBlock.__repr__(self)
+        repr += "\n"
+        for block in self.getBlocks():
+            repr+= block.__repr__()
+        return repr
+
+    def dump(self):
+        print("=========== Start of Model Dump ===========")
+        print(self)
+        print("=========== End of Model Dump =============\n")
+
+    def dumpSignals(self):
+        print("=========== Start of Signals Dump ===========")
+        for block in self.getBlocks():
+            print("%s:%s" % (block.getBlockName(), block.getBlockType()))
+            print(str(block.getSignal()) + "\n")
+        print("=========== End of Signals Dump =============\n")
+    
+    def resetSignals(self):
+        for block in self.getBlocks():
+            block.resetSignals()
+    
+    def getSignal(self, name_output = None):
+        name_output = "OUT1" if name_output == None else name_output
+        portBlock = self.getBlockByName(name_output)
+        assert portBlock != None
+        return portBlock.getSignal("OUT1")
+    
+    
+class AddOneBlock(CBD):
+    """
+    Block adds a one to the input (used a lot for mux)
+    """
+    def __init__(self, block_name, faultOrder=3):
+        CBD.__init__(self, block_name, ["IN1"], ["OUT1"])
+        self.addBlock(ConstantBlock(block_name="OneConstant", value=1))
+        self.addBlock(AdderBlock("PlusOne"))
+        self.addConnection("IN1", "PlusOne")
+        self.addConnection("OneConstant", "PlusOne")
+        self.addConnection("PlusOne", "OUT1")
+
+class DerivatorBlock(CBD):
+    """
+    The derivator block is a CBD that calculates the derivative
+    """
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["IN1", "delta_t", "IC"], ["OUT1"])
+        self.addBlock(ProductBlock(block_name="multIc"))
+        self.addBlock(NegatorBlock(block_name="neg1"))
+        self.addBlock(AdderBlock(block_name="sum1"))
+        self.addBlock(DelayBlock(block_name="delay"))
+        self.addBlock(NegatorBlock(block_name="neg2"))
+        self.addBlock(AdderBlock(block_name="sum2"))
+        self.addBlock(ProductBlock(block_name="mult"))
+        self.addBlock(InverterBlock(block_name="inv"))
+        
+        self.addConnection("IC", "multIc")
+        self.addConnection("delta_t", "multIc")
+        self.addConnection("multIc", "neg1")
+        self.addConnection("neg1", "sum1")
+        self.addConnection("IN1", "sum1")
+        self.addConnection("sum1", "delay", input_port_name="IC")
+        self.addConnection("IN1", "delay", input_port_name="IN1")
+        self.addConnection("delay", "neg2")
+        self.addConnection("neg2", "sum2")
+        self.addConnection("IN1", "sum2")
+        self.addConnection("sum2", "mult")
+        self.addConnection("delta_t", "inv")
+        self.addConnection("inv", "mult")
+        self.addConnection("mult", "OUT1")
+        
+
+class IntegratorBlock(CBD):
+    """
+    The integrator block is a CBD that calculates the integration
+    """
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["IN1", "delta_t", "IC"], ["OUT1"])
+        self.addBlock(ConstantBlock(block_name="zero", value=0))
+        self.addBlock(DelayBlock(block_name="delayIn"))
+        self.addBlock(ProductBlock(block_name="multDelta"))
+        self.addBlock(DelayBlock(block_name="delayState"))
+        self.addBlock(AdderBlock(block_name="sumState"))
+        
+        self.addConnection("zero", "delayIn", input_port_name="IC")
+        self.addConnection("IN1", "delayIn", input_port_name="IN1")
+        self.addConnection("delayIn", "multDelta")
+        self.addConnection("delta_t", "multDelta")
+        self.addConnection("multDelta", "sumState")
+        self.addConnection("IC", "delayState", input_port_name="IC")
+        self.addConnection("delayState", "sumState")
+        self.addConnection("sumState", "delayState", input_port_name="IN1")
+        self.addConnection("sumState", "OUT1")
+        
+        
+
+""" This module implements a dependency graph
+    @author: Marc Provost
+    @organization: McGill University
+    @license: GNU General Public License
+    @contact: marc.provost@mail.mcgill.ca
+"""
+
+import copy
+class DepNode:
+    """ Class implementing a node in the dependency graph.
+    """
+
+    def __init__(self, object):
+        """ DepNode's constructor.
+                @param object: Reference to a semantic object identifying the node
+                @type object: Object
+        """
+        self.__object = object
+        self.__isMarked	 = False
+
+    def mark(self):
+        self.__isMarked = True
+
+    def unMark(self):
+        self.__isMarked = False
+
+    def isMarked(self):
+        return self.__isMarked
+
+    def getMappedObj(self):
+        return self.__object
+
+    def __repr__(self):
+        return "DepNode :: "+str(self.__object)
+
+class DepGraph:
+    """ Class implementing dependency graph.
+    """
+
+    def __init__(self):
+        """ DepGraph's constructor.
+        """
+        #Dict holding a mapping "Object -> DepNode"
+        self.__semanticMapping = {}
+
+        #map object->list of objects depending on object
+        self.__dependents = {}
+        #map object->list of objects that influences object
+        self.__influencers = {}
+
+    def __repr__(self):
+        repr = "Dependents: \n"
+        for dep in self.__dependents:
+            repr += dep.getBlockName() + ":" + str(self.__dependents[dep]) + "\n"
+        repr += "Influencers: \n"
+        for infl in self.__influencers:
+            repr += infl.getBlockName() + ":" + str(self.__influencers[infl]) + "\n"
+        return repr
+
+    def addMember(self, object):
+        """ Add an object mapped to this graph.
+                @param object: the object to be added
+                @type object: Object
+                @raise ValueError: If object is already in the graph
+        """
+        if not self.hasMember(object):
+            if not isinstance(object, CBD):
+                node = DepNode(object)
+                self.__dependents[object] = []
+                self.__influencers[object] = []
+                self.__semanticMapping[object] = node
+            else:
+                for block in object.getBlocks():
+                    self.addMember(block)
+        else:
+            raise ValueError("Specified object is already member of this graph")
+
+    def hasMember(self, object):
+        return self.__semanticMapping.has_key(object)
+
+    def removeMember(self, object):
+        """ Remove a object from this graph.
+                @param object: the object to be removed
+                @type object: Object
+                @raise ValueError: If object is not in the graph
+        """
+        if self.hasMember(object):
+            for dependent in self.getDependents(object):
+                self.__influencers[dependent].remove(object)
+            for influencer in self.getInfluencers(object):
+                self.__dependents[influencer].remove(object)
+
+            del self.__dependents[object]
+            del self.__influencers[object]
+            del self.__semanticMapping[object]
+        else:
+            raise ValueError("Specified object is not member of this graph")
+
+    def setDependency(self, dependent, influencer, curIt):
+        """
+            Creates a dependency between two objects.
+                @param dependent: The object which depends on the other
+                @param influcencer: The object which influences the other
+                @type dependent: Object
+                @type dependent: Object
+                @raise ValueError: if depedent or influencer is not member of this graph
+                @raise ValueError: if the dependency already exists
+        """
+
+        # Link CBD outputs
+        if isinstance(influencer, CBD):
+            # When there is more than one connection from a CBD to one and the same block,
+            # more than one dependency should be set, as there is more than one underlying
+            # output block
+            for output_port in [ y.output_port for (x,y) in dependent.getLinksIn().iteritems() if y.block == influencer ]:
+                self.setDependency(dependent, influencer.getBlockByName(output_port), curIt)
+            return
+
+        # Link CBD inputs
+        if isinstance(dependent, CBD):
+            cbd = dependent
+            directlyConnected = influencer.parent if isinstance(influencer, OutputPortBlock) else influencer
+            inputnames = dependent.getInputName(directlyConnected)
+
+            # When one influencer has multiple connections to this CBD, call this function once fo
+            for inputname in inputnames:
+                inputtingBlock = dependent.getBlockByName(inputname)
+                thisdep = inputtingBlock
+                self.setDependency(thisdep, influencer, curIt)
+            return
+
+        if self.hasMember(dependent) and self.hasMember(influencer):
+            if not influencer in self.__influencers[dependent] and\
+                 not dependent in self.__dependents[influencer]:
+                self.__influencers[dependent].append(influencer)
+                self.__dependents[influencer].append(dependent)
+        else:
+            if not self.hasMember(dependent):
+                raise ValueError("Specified dependent object is not member of this graph")
+            if not self.hasMember(influencer):
+                print(influencer)
+                raise ValueError("Specified influencer object is not member of this graph")
+
+    def hasDependency(self, dependent, influencer):
+        if self.hasMember(dependent) and self.hasMember(influencer):
+            return influencer in self.__influencers[dependent] and\
+                         dependent in self.__dependents[influencer]
+        else:
+            if not self.hasMember(dependent):
+                raise ValueError("Specified dependent object is not member of this graph")
+            if not self.hasMember(influencer):
+                raise ValueError("Specified influencer object is not member of this graph")
+
+    def unsetDependency(self, dependent, influencer):
+        """ Removes a dependency between two objects.
+                @param dependent: The object which depends on the other
+                @param influcencer: The object which influences the other
+                @type dependent: Object
+                @type dependent: Object
+                @raise ValueError: if depedent or influencer is not member of this graph
+                @raise ValueError: if the dependency does not exists
+        """
+        if self.hasMember(dependent) and self.hasMember(influencer):
+            if influencer in self.__influencers[dependent] and\
+                 dependent in self.__dependents[influencer]:
+                self.__influencers[dependent].remove(influencer)
+                self.__dependents[influencer].remove(dependent)
+            else:
+                raise ValueError("Specified dependency does not exists")
+        else:
+            if not self.hasMember(dependent):
+                raise ValueError("Specified dependent object is not member of this graph")
+            if not self.hasMember(influencer):
+                raise ValueError("Specified influencer object is not member of this graph")
+
+    def getDependents(self, object):
+        if self.hasMember(object):
+            return copy.copy(self.__dependents[object])
+        else:
+            raise ValueError("Specified object is not member of this graph")
+
+    def getInfluencers(self, object):
+        if self.hasMember(object):
+            return copy.copy(self.__influencers[object])
+        else:
+            raise ValueError("Specified object is not member of this graph")
+
+    def getStrongComponents(self, curIt = 1):
+        return self.__strongComponents(curIt)
+
+    def __getDepNode(self, object):
+        if self.hasMember(object):
+            return self.__semanticMapping[object]
+        else:
+            raise ValueError("Specified object is not a member of this graph")
+
+    def __mark(self, object):
+        self.__getDepNode(object).mark()
+
+    def __unMark(self, object):
+        self.__getDepNode(object).unMark()
+
+    def __isMarked(self, object):
+        return self.__getDepNode(object).isMarked()
+
+    def __topoSort(self):
+        """ Performs a topological sort on the graph.
+        """
+        for object in self.__semanticMapping.keys():
+            self.__unMark(object)
+
+        sortedList = []
+
+        for object in self.__semanticMapping.keys():
+            if not self.__isMarked(object):
+                self.__dfsSort(object, sortedList)
+
+        return sortedList
+
+    def __dfsSort(self, object, sortedList):
+        """ Performs a depth first search collecting
+                the objects in topological order.
+                @param object: the currently visited object.
+                @param sortedList: partial sorted list of objects
+                @type object: Object
+                @type sortedList: list Of Object
+        """
+
+        if not self.__isMarked(object):
+            self.__mark(object)
+
+            for influencer in self.getInfluencers(object):
+                self.__dfsSort(influencer, sortedList)
+
+            sortedList.append(object)
+
+    def __strongComponents(self, curIt):
+        """ Determine the strong components of the graph
+                @rtype: list of list of Object
+        """
+        strongComponents = []
+        sortedList = self.__topoSort()
+
+        for object in self.__semanticMapping.keys():
+            self.__unMark(object)
+
+        sortedList.reverse()
+
+        for object in sortedList:
+            if not self.__isMarked(object):
+                component = []
+                self.__dfsCollect(object, component, curIt)
+                strongComponents.append(component)
+
+        strongComponents.reverse()
+        return strongComponents
+
+    def __dfsCollect(self, object, component, curIt):
+        """ Collects objects member of a strong component.
+                @param object: Node currently visited
+                @param component: current component
+                @type object: Object
+                @type component: List of Object
+        """
+        if not self.__isMarked(object):
+            self.__mark(object)
+
+            for dependent in self.getDependents(object):
+                self.__dfsCollect(dependent, component, curIt)
+
+            component.append(object)
+
+
+
+
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Source/CBDDraw.py

@@ -0,0 +1,54 @@
+from CBD import *
+
+def draw(cbd, filename, colors=None):
+	""" Output cbd as a dot script to filename.
+
+	colors is a dictionary of blockname => color
+	"""
+	f = open(filename, "w")
+	write = lambda s: f.write(s)
+
+	write("""
+digraph graphname {
+ """)
+
+	if colors == None:
+		colors = {}
+
+	def writeBlock(block):
+		if isinstance(block, ConstantBlock):
+			label = block.getBlockType() + " (" + block.getBlockName() + ")\\n" + str(block.getValue())
+		else:
+			label = block.getBlockType() + " (" + block.getBlockName() + ")"
+
+		shape = ""
+		if isinstance(block, CBD):
+			shape=",shape=Msquare"
+
+		col = ""
+		if block.getBlockName() in colors:
+			col = ", color=\"{0}\", fontcolor=\"{0}\"".format(colors[block.getBlockName()])
+
+		write("{b} [label=\"{lbl}\"{shape}{col}];\n".format(b=block.getBlockName(),
+			lbl=label,
+			shape=shape,
+			col=col))
+
+
+	for block in cbd.getBlocks():
+		writeBlock(block)
+		for (name, other) in  block.getLinksIn().iteritems():
+			label = ""
+
+			if not name.startswith("IN"):
+				label=name
+
+			if not other.output_port.startswith("OUT"):
+				label = label + " / " + other.output_port
+
+			write("{a} -> {b} [label=\"{lbl}\"];\n".format(a=other.block.getBlockName(),
+				b=block.getBlockName(),
+				lbl=label))
+
+	write("\n}")
+

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Source/naivelog.py

@@ -0,0 +1,129 @@
+import os
+import sys
+import datetime
+(DEBUG, INFO, WARNING, ERROR, FATAL) = (0, 1, 2, 3, 4)
+
+def strToLevel(elvl):
+	if elvl == "DEBUG":
+		return DEBUG
+	if elvl == "INFO":
+		return INFO
+	if elvl == "WARNING":
+		return WARNING
+	if elvl == "ERROR":
+		return ERROR
+	if elvl == "FATAL":
+		return FATAL
+	else:
+		return None
+
+def levelToStr(lvl):
+	if lvl == DEBUG:
+		return "DEBUG"
+	if lvl == INFO:
+		return "INFO"
+	if lvl == WARNING:
+		return "WARNING"
+	if lvl == ERROR:
+		return "ERROR"
+	if lvl == FATAL:
+		return "FATAL"
+	return None
+
+
+def levelToShortStr(lvl):
+	if lvl == DEBUG:
+		return "DBUG"
+	if lvl == INFO:
+		return "INFO"
+	if lvl == WARNING:
+		return "WARN"
+	if lvl == ERROR:
+		return "ERROR"
+	if lvl == FATAL:
+		return "FATAL"
+	return None
+
+class Logger:
+	def __init__(self, modulename, level, crashlevel):
+		self.__modulename = modulename
+		self.__level = level
+		self.__crashlevel = crashlevel
+
+	def debug(self, mainstr, *args, **kwargs):
+		self.log(DEBUG, mainstr, *args, **kwargs)
+	def info(self, mainstr, *args, **kwargs):
+		self.log(INFO, mainstr, *args, **kwargs)
+	def warning(self, mainstr, *args, **kwargs):
+		self.log(WARNING, mainstr, *args, **kwargs)
+	def error(self, mainstr, *args, **kwargs):
+		self.log(ERROR, mainstr, *args, **kwargs)
+	def fatal(self, mainstr, *args, **kwargs):
+		self.log(FATAL, mainstr, *args, **kwargs)
+
+	def log(self, level, mainstr, *args, **kwargs):
+		if level >= self.__level:
+			sys.stdout.write(self.formatmsg(level,str(mainstr).format(*args, **kwargs)))
+
+		if level >= self.__crashlevel:
+			exit(1)
+
+	def setLevel(self, level):
+		self.__level = level
+
+	def formatmsg(self, level, mainstr):
+		class bcolors:
+			HEADER = '\033[95m'
+			OKBLUE = '\033[94m'
+			OKGREEN = '\033[92m'
+			WARNING = '\033[93m'
+			FAIL = '\033[91m'
+			ENDC = '\033[0m'
+	
+
+		col = bcolors.OKGREEN
+		if level >= WARNING:
+			col = bcolors.WARNING
+		if level >= ERROR:
+			col = bcolors.FAIL
+
+		return "{startcol}[{now:%H:%M:%S.%f} {module} {lvl}] {mainstr}{endcol}\n".format(
+				lvl=levelToShortStr(level),
+				module=self.__modulename,
+				now=datetime.datetime.today(),
+				mainstr=mainstr,
+				startcol=col,
+				endcol=bcolors.ENDC);
+
+defaultLogLevel = INFO
+defaultCrashLevel = FATAL
+
+def getAbstractLogLevel(env, default):
+	elvl = os.environ[env] if env in os.environ else ''
+
+	lvl = strToLevel(elvl)
+	if lvl:
+		return lvl
+	else:
+		return default
+
+def getLogLevel():
+	return getAbstractLogLevel('NAIVE_LOGLEVEL', defaultLogLevel)
+
+def getCrashLevel():
+	return getAbstractLogLevel('NAIVE_CRASHLEVEL', defaultCrashLevel)
+
+def getLogger(modulename):
+	return Logger(modulename, getLogLevel(), getCrashLevel())
+
+if __name__ == "__main__":
+	l = getLogger('testmodule')
+	l.info("bla");
+	l.info("test nummer {}{}", 2, " is good")
+	l.info("test {hier} is ook ok", hier=3, daar=4)
+	l.info("should not see this")
+
+
+	l2 = getLogger('testmodule.m2')
+	l2.info("More info")
+	l2.info("and even more")

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Source/plot.py

@@ -0,0 +1,49 @@
+__author__ = 'joachimdenil'
+
+from math import ceil
+import matplotlib
+matplotlib.use('TkAgg')
+from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg, NavigationToolbar2TkAgg
+from matplotlib.figure import Figure
+from matplotlib.lines import Line2D
+import numpy as np
+import threading
+
+try:
+    import Tkinter as Tk
+except ImportError:
+    import tkinter as Tk
+
+class ScopeWindow():
+    def __init__(self, theOutportRefs, names):
+        """
+        Plot results in a Tk window using matlplotlib
+        @param theOutportRefs: array of values to plot: [[x1,x2,xn], ... ,[y1,y2, , yn]]
+        @param names: the labels for each of the plots: list [name1, name2, ...,  namen]
+        @return:
+        """
+        self.root = Tk.Tk()
+        self.f = Figure()
+        n = len(theOutportRefs)
+        n = int(ceil(n*1.00/2))
+        index = 1
+        self.ax = []
+        for outport in theOutportRefs:
+            self.ax.append(self.f.add_subplot(n, 2, index))
+            # add values:
+            self.ax[index-1].plot(outport, 'ro')
+            self.ax[index-1].set_xlabel('t')
+            self.ax[index-1].set_ylabel(names[index-1])
+            index+=1
+
+        self.canvas = FigureCanvasTkAgg(self.f, master=self.root)
+        self.canvas.get_tk_widget().pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
+        self.canvas.show()
+
+        self.toolbar = NavigationToolbar2TkAgg( self.canvas, self.root )
+        self.toolbar.pack(side=Tk.TOP, fill=Tk.BOTH, expand=1)
+        self.toolbar.update()
+
+        self.button = Tk.Button(master=self.root, text='Quit', command=self.root.destroy)
+        self.button.pack(side=Tk.BOTTOM)
+        self.root.mainloop()

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Test/CounterTest.py

@@ -0,0 +1,48 @@
+__author__ = 'joachimdenil'
+
+import unittest
+from CBDMultipleOutput.Source.CBD import *
+from CBDMultipleOutput.Source.plot import ScopeWindow
+from basicCBDTest import BasicCBDTestCase
+
+NUM_DISCR_TIME_STEPS = 10
+
+class FlattenCBDTest(unittest.TestCase):
+    def setUp(self):
+        self.CBD = CBD("block_under_test")
+
+    def _run(self, num_steps=1, step = 1):
+        self.CBD.run(num_steps, step)
+
+    def _getSignal(self, blockname, output_port = None):
+        foundBlocks = [ block for block in self.CBD.getBlocks() if block.getBlockName() == blockname ]
+        signal =  foundBlocks[0].getSignal(name_output = output_port)
+        if len(foundBlocks) == 1:
+            return [x.value for x in signal]
+        else:
+            raise Exception("No single block with name " + blockname + " found")
+
+    def testCounter(self):
+        self.CBD.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.CBD.addBlock(DelayBlock(block_name="s"))
+        self.CBD.addConnection("zero", "s", input_port_name="IC")
+        self.CBD.addBlock(ConstantBlock(block_name="one", value=1.0))
+        self.CBD.addBlock(AdderBlock(block_name="plusOne"))
+        self.CBD.addConnection("one", "plusOne")
+        self.CBD.addConnection("s", "plusOne")
+        self.CBD.addConnection("plusOne", "s")
+
+        self._run(NUM_DISCR_TIME_STEPS)
+        ScopeWindow([self._getSignal("zero"), self._getSignal("one"), self._getSignal("s")],
+            ["zero", "one", "s"] )
+        self.assertEquals(self._getSignal("s"), [float(x) for x in range(NUM_DISCR_TIME_STEPS)])
+
+def suite():
+    """Returns a suite containing all the test cases in this module."""
+    suite1 = unittest.makeSuite(BasicCBDTestCase)
+
+    return unittest.TestSuite((suite1))
+
+if __name__ == '__main__':
+    # When this module is executed from the command-line, run all its tests
+    unittest.main()

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Test/basicCBDTest.py

@@ -0,0 +1,551 @@
+#!/usr/bin/env python
+#
+# Unit tests for all the basic CBD blocks, discrete-time CBD. 
+
+import unittest
+
+from CBDMultipleOutput.Source.CBD import *
+
+NUM_DISCR_TIME_STEPS = 5
+
+class BasicCBDTestCase(unittest.TestCase):
+  def setUp(self):
+    self.CBD = CBD("CBD_for_block_under_test")    
+    
+  def _run(self, num_steps=1, delta_t = 1.0):
+    self.CBD.run(num_steps, delta_t)      
+      
+  def _getSignal(self, blockname, output_port = None):
+    foundBlocks = [ block for block in self.CBD.getBlocks() if block.getBlockName() == blockname ]
+    numFoundBlocks = len(foundBlocks)  
+    if numFoundBlocks == 1:
+      signal =  foundBlocks[0].getSignal(name_output = output_port)
+      return [x.value for x in signal]
+    else:
+      raise Exception(str(numFoundBlocks) + " blocks with name " + blockname + " found.\nExpected a single block.")  
+  
+  def testConstantBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=3.3))
+
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("c1"), [3.3] * NUM_DISCR_TIME_STEPS)
+    
+  def testNegatorBlockPos(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=6.0))
+    self.CBD.addBlock(NegatorBlock(block_name="n"))
+    self.CBD.addConnection("c1", "n")
+
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("n"), [-6.0] * NUM_DISCR_TIME_STEPS)  
+  
+  def testNegatorBlockNeg(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=-6.0))
+    self.CBD.addBlock(NegatorBlock(block_name="n"))
+    self.CBD.addConnection("c1", "n")
+
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("n"), [6.0] * NUM_DISCR_TIME_STEPS)  
+    
+  def testNegatorBlockZero(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=0.0))
+    self.CBD.addBlock(NegatorBlock(block_name="n"))
+    self.CBD.addConnection("c1", "n")
+
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("n"), [0.0] * NUM_DISCR_TIME_STEPS)  
+    
+  def testInverterBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=5.0))
+    self.CBD.addBlock(InverterBlock(block_name="i1"))
+    self.CBD.addBlock(InverterBlock(block_name="i2"))
+
+    self.CBD.addConnection("c1", "i1")
+    self.CBD.addConnection("i1", "i2")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("i1"), [0.2] * NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("i2"), [5.0] * NUM_DISCR_TIME_STEPS)
+
+  def testAdderBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=6.0))
+    self.CBD.addBlock(AdderBlock(block_name="a"))
+    
+    self.CBD.addConnection("c1", "a")
+    self.CBD.addConnection("c2", "a")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a"), [8.0] * NUM_DISCR_TIME_STEPS)
+    
+  def testAdderBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=-6.0))
+    self.CBD.addBlock(AdderBlock(block_name="a"))
+    
+    self.CBD.addConnection("c1", "a")
+    self.CBD.addConnection("c2", "a")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a"), [-4.0] * NUM_DISCR_TIME_STEPS)    
+    
+  def testProductBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.0))
+    self.CBD.addBlock(ProductBlock(block_name="p"))
+    
+    self.CBD.addConnection("c1", "p")
+    self.CBD.addConnection("c2", "p")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("p"), [10.0] * 5)
+
+  def testProductBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=1.0/2.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=4.0))
+    self.CBD.addBlock(ProductBlock(block_name="p"))
+    
+    self.CBD.addConnection("c1", "p")
+    self.CBD.addConnection("c2", "p")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("p"), [2.0] * 5)
+    
+  def testGenericBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.2))
+    self.CBD.addBlock(GenericBlock(block_name="g", block_operator="ceil"))
+    
+    self.CBD.addConnection("c1", "g")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("g"), [3.0] * 5)  
+    
+  def testRootBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=8.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=3.0))
+    self.CBD.addBlock(RootBlock(block_name="g"))
+
+    self.CBD.addConnection("c1", "g")
+    self.CBD.addConnection("c2", "g")
+    self._run(1)
+    self.assertEquals(self._getSignal("g"), [2.0])
+        
+  def testRootBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=9.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=2.0))
+    self.CBD.addBlock(RootBlock(block_name="g"))
+
+    self.CBD.addConnection("c1", "g")
+    self.CBD.addConnection("c2", "g")
+    self._run(1)
+    self.assertEquals(self._getSignal("g"), [3.0])
+        
+  def testModuloBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=8.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=3.0))
+    self.CBD.addBlock(ModuloBlock(block_name="g"))
+
+    self.CBD.addConnection("c1", "g")
+    self.CBD.addConnection("c2", "g")
+    self._run(1)
+    self.assertEquals(self._getSignal("g"), [2.0])
+
+  def testModuloBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=8.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=8.0))
+    self.CBD.addBlock(ModuloBlock(block_name="g"))
+
+    self.CBD.addConnection("c1", "g")
+    self.CBD.addConnection("c2", "g")
+    self._run(1)
+    self.assertEquals(self._getSignal("g"), [0.0])
+
+  def testPreviousValueDelayBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="ZeroConstant", value=0.0))
+    self.CBD.addBlock(SequenceBlock(block_name="seq", sequence=[0, 2, 4, 6, 8, 10, 12]))
+    self.CBD.addBlock(DelayBlock(block_name="d"))
+    
+    self.CBD.addConnection("ZeroConstant", "d", input_port_name="IC")
+    self.CBD.addConnection("seq", "d")
+    
+    self._run(7, 0.5)
+    self.assertEquals(self._getSignal("d"), [0, 0, 2, 4, 6, 8, 10])    
+    
+  def testPreviousValueDelayBlock2(self):
+    self.CBD.addBlock(SequenceBlock(block_name="FirstSeq", sequence=[2, 12, 22, 23, 32, 11, 91]))
+    self.CBD.addBlock(SequenceBlock(block_name="SecSeq", sequence=[5, 5, 5, 5, 3, 3, 3]))
+    self.CBD.addBlock(DelayBlock(block_name="prev"))
+    self.CBD.addConnection(self.CBD.getBlockByName("FirstSeq"), "prev")
+    self.CBD.addConnection(self.CBD.getBlockByName("SecSeq"), "prev", input_port_name="IC")
+    self._run(7)  
+    self.assertEquals(self._getSignal("prev"), [5, 2, 12, 22, 23, 32, 11])    
+          
+  def testTimeBlock(self):
+    self.CBD.addBlock(TimeBlock(block_name="t"))
+    self._run(4)
+    self.assertEquals(self._getSignal("t"), [0.0, 1.0, 2.0, 3.0])
+
+  def testLessThanBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=6.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=-5.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c3", value=0))
+    self.CBD.addBlock(LessThanBlock(block_name="lt1"))
+    self.CBD.addBlock(LessThanBlock(block_name="lt2"))
+    self.CBD.addBlock(LessThanBlock(block_name="lt3"))
+    
+    self.CBD.addConnection("c1", "lt1")
+    self.CBD.addConnection("c1", "lt1", input_port_name="IC")
+    self.CBD.addConnection("c1", "lt2")
+    self.CBD.addConnection("c2", "lt2", input_port_name="IC")
+    self.CBD.addConnection("c2", "lt3")
+    self.CBD.addConnection("c3", "lt3", input_port_name="IC")
+
+    self._run(1)
+    self.assertEquals(self._getSignal("lt1"), [0.0])  
+    self.assertEquals(self._getSignal("lt2"), [0.0])  
+    self.assertEquals(self._getSignal("lt3"), [1.0])  
+    
+  def testEqualsBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=6.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=-5.0))
+    self.CBD.addBlock(EqualsBlock(block_name="eq1"))
+    self.CBD.addBlock(EqualsBlock(block_name="eq2"))
+    
+    self.CBD.addConnection("c1", "eq1")
+    self.CBD.addConnection("c1", "eq1", input_port_name="IC")
+    self.CBD.addConnection("c1", "eq2")
+    self.CBD.addConnection("c2", "eq2", input_port_name="IC")
+    
+    self._run(1)
+    self.assertEquals(self._getSignal("eq1"), [1.0])  
+    self.assertEquals(self._getSignal("eq2"), [0.0])  
+    
+  def testNotBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="One", value=1))
+    self.CBD.addBlock(NotBlock(block_name="NotBlock"))
+    self.CBD.addConnection("One", "NotBlock")      
+    self._run(1)
+    self.assertEquals(self._getSignal("NotBlock"), [0])    
+    
+  def testNotBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="Zero", value=0))
+    self.CBD.addBlock(NotBlock(block_name="NotBlock"))
+    self.CBD.addConnection("Zero", "NotBlock")      
+    self._run(1)      
+    self.assertEquals(self._getSignal("NotBlock"), [1])        
+    
+  def testOrBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="One", value=1))
+    self.CBD.addBlock(ConstantBlock(block_name="Zero", value=0))
+    self.CBD.addBlock(OrBlock(block_name="OrBlock1"))
+    self.CBD.addConnection("Zero", "OrBlock1")    
+    self.CBD.addConnection("Zero", "OrBlock1")  
+    
+    self.CBD.addBlock(OrBlock(block_name="OrBlock2"))
+    self.CBD.addConnection("One", "OrBlock2")    
+    self.CBD.addConnection("Zero", "OrBlock2")
+    
+    self.CBD.addBlock(OrBlock(block_name="OrBlock3"))    
+    self.CBD.addConnection("One", "OrBlock3")    
+    self.CBD.addConnection("One", "OrBlock3")
+    
+    self.CBD.addBlock(OrBlock(block_name="OrBlock4", numberOfInputs=4))
+    self.CBD.addConnection("Zero", "OrBlock4")    
+    self.CBD.addConnection("Zero", "OrBlock4")
+    self.CBD.addConnection("One", "OrBlock4")
+    self.CBD.addConnection("Zero", "OrBlock4")
+        
+    self._run(1)
+    self.assertEquals(self._getSignal("OrBlock1"), [0])      
+    self.assertEquals(self._getSignal("OrBlock2"), [1])      
+    self.assertEquals(self._getSignal("OrBlock3"), [1])      
+    self.assertEquals(self._getSignal("OrBlock4"), [1])      
+    
+  def testAndBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="One", value=1))
+    self.CBD.addBlock(ConstantBlock(block_name="Zero", value=0))
+    self.CBD.addBlock(AndBlock(block_name="AndBlock1"))
+    self.CBD.addConnection("Zero", "AndBlock1")    
+    self.CBD.addConnection("Zero", "AndBlock1")  
+    
+    self.CBD.addBlock(AndBlock(block_name="AndBlock2"))
+    self.CBD.addConnection("One", "AndBlock2")    
+    self.CBD.addConnection("Zero", "AndBlock2")
+    
+    self.CBD.addBlock(AndBlock(block_name="AndBlock3"))    
+    self.CBD.addConnection("One", "AndBlock3")    
+    self.CBD.addConnection("One", "AndBlock3")
+    
+    self.CBD.addBlock(AndBlock(block_name="AndBlock4"))    
+    self.CBD.addConnection("Zero", "AndBlock4")    
+    self.CBD.addConnection("One", "AndBlock4")
+    
+    self.CBD.addBlock(AndBlock(block_name="AndBlock5", numberOfInputs=4))
+    self.CBD.addConnection("Zero", "AndBlock5")    
+    self.CBD.addConnection("Zero", "AndBlock5")
+    self.CBD.addConnection("One", "AndBlock5")
+    self.CBD.addConnection("Zero", "AndBlock5")
+        
+    self._run(1)
+    self.assertEquals(self._getSignal("AndBlock1"), [0])      
+    self.assertEquals(self._getSignal("AndBlock2"), [0])      
+    self.assertEquals(self._getSignal("AndBlock3"), [1])      
+    self.assertEquals(self._getSignal("AndBlock4"), [0])      
+    self.assertEquals(self._getSignal("AndBlock5"), [0])      
+    
+  def testSequenceBlock(self):
+    self.CBD.addBlock(SequenceBlock(block_name="FirstSeq", sequence=[2, 2, 2, 3, 2, 1, 1]))
+    self._run(7)  
+    self.assertEquals(self._getSignal("FirstSeq"), [2, 2, 2, 3, 2, 1, 1])
+
+  def testLoggingBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="One", value=1))
+    self.CBD.addBlock(LoggingBlock("Test", "Logging block test with level is error", level.ERROR))
+    self.CBD.addConnection("One", "Test")
+    self._run(1)
+    
+
+  def testLinearStrongComponent(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.5))
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=-5))
+    self.CBD.addBlock(AdderBlock(block_name="a1"))
+    self.CBD.addBlock(AdderBlock(block_name="a3"))
+    self.CBD.addBlock(AdderBlock(block_name="a2"))
+
+    self.CBD.addConnection("a3", "a1")
+    self.CBD.addConnection("c1", "a1")
+    self.CBD.addConnection("a1", "a3")
+    self.CBD.addConnection("a2", "a3")
+    self.CBD.addConnection("c2", "a2")
+    self.CBD.addConnection("a3", "a2")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a1"), [-5.5]*5)
+    self.assertEquals(self._getSignal("a2"), [5.0]*5)
+    self.assertEquals(self._getSignal("a3"), [-0.5]*5)
+    
+  def testLinearStrongComponentWithDelay(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=3.0))
+    self.CBD.addBlock(AdderBlock(block_name="sum"))
+    self.CBD.addBlock(DelayBlock(block_name="delay"))
+    self.CBD.addBlock(NegatorBlock(block_name="neg"))
+
+    self.CBD.addConnection("c1", "sum")
+    self.CBD.addConnection("neg", "sum")
+    self.CBD.addConnection("sum", "delay", input_port_name="IC")
+    self.CBD.addConnection("delay", "neg")
+    self.CBD.addConnection("neg", "delay")
+    
+    self._run(1)
+    self.assertEquals(self._getSignal("delay"), [1.5])
+    
+  def testLinearStrongComponentWithMult(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=3))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=5))
+    self.CBD.addBlock(AdderBlock(block_name="a"))
+    self.CBD.addBlock(ProductBlock(block_name="p"))
+
+    self.CBD.addConnection("c1", "a")
+    self.CBD.addConnection("p", "a")
+    self.CBD.addConnection("a", "p")
+    self.CBD.addConnection("c2", "p")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a"), [-0.75]*5)
+    self.assertEquals(self._getSignal("p"), [-3.75]*5)
+    
+  def testLinearStrongComponentWithNeg(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=5))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=8))
+    self.CBD.addBlock(AdderBlock(block_name="a1"))
+    self.CBD.addBlock(AdderBlock(block_name="a2"))
+    self.CBD.addBlock(NegatorBlock(block_name="n"))
+
+    self.CBD.addConnection("c1", "a1")
+    self.CBD.addConnection("a2", "a1")
+    self.CBD.addConnection("c2", "a2")
+    self.CBD.addConnection("n", "a2")
+    self.CBD.addConnection("a1", "n")  
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a1"), [6.5]*5)
+    self.assertEquals(self._getSignal("a2"), [1.5]*5)  
+    self.assertEquals(self._getSignal("n"), [-6.5]*5)  
+    
+  def testTwoLinearStrongComponent(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=3))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=2))
+    self.CBD.addBlock(ConstantBlock(block_name="c3", value=1.5))
+    self.CBD.addBlock(ConstantBlock(block_name="c4", value=1))
+    self.CBD.addBlock(AdderBlock(block_name="a1"))
+    self.CBD.addBlock(AdderBlock(block_name="a2"))
+    self.CBD.addBlock(AdderBlock(block_name="a3"))
+    self.CBD.addBlock(AdderBlock(block_name="a4"))
+    self.CBD.addBlock(AdderBlock(block_name="a5"))
+    self.CBD.addBlock(ProductBlock(block_name="p"))
+    self.CBD.addBlock(NegatorBlock(block_name="n1"))
+    self.CBD.addBlock(NegatorBlock(block_name="n2"))
+
+    self.CBD.addConnection("a3", "a1")
+    self.CBD.addConnection("c1", "a1")
+    self.CBD.addConnection("c2", "a2")
+    self.CBD.addConnection("a3", "a2")
+    self.CBD.addConnection("a1", "a3")
+    self.CBD.addConnection("a2", "a3")
+    self.CBD.addConnection("a3", "p")
+    self.CBD.addConnection("c3", "p")
+    self.CBD.addConnection("p", "n1")
+    self.CBD.addConnection("n1", "a4")
+    self.CBD.addConnection("a5", "a4")
+    self.CBD.addConnection("c4", "a5")
+    self.CBD.addConnection("n2", "a5")
+    self.CBD.addConnection("a4", "n2")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("a1"), [-2.0]*5)
+    self.assertEquals(self._getSignal("a2"), [-3.0]*5)
+    self.assertEquals(self._getSignal("a3"), [-5.0]*5)
+    self.assertEquals(self._getSignal("a4"), [4.25]*5)
+    self.assertEquals(self._getSignal("a5"), [-3.25]*5)
+    self.assertEquals(self._getSignal("p"), [-7.5]*5)
+    self.assertEquals(self._getSignal("n1"), [7.5]*5)
+    self.assertEquals(self._getSignal("n2"), [-4.25]*5)
+        
+  def testNonLinearStrongComponent(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=15))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=10))
+    self.CBD.addBlock(AdderBlock(block_name="a1"))
+    self.CBD.addBlock(AdderBlock(block_name="a2"))
+    self.CBD.addBlock(ProductBlock(block_name="p"))
+
+    self.CBD.addConnection("c2", "a1")
+    self.CBD.addConnection("p", "a1")
+    self.CBD.addConnection("a1", "p")
+    self.CBD.addConnection("a2", "p")
+    self.CBD.addConnection("p", "a2")
+    self.CBD.addConnection("c1", "a2")
+    self.assertRaises(SystemExit, self._run, 5)    
+    
+  def initializeFuncDerBas(self):
+    #f(t) = 5*t  
+    CBDFunc = CBD("function", output_ports = ["OUT1"])
+    CBDFunc.addBlock(TimeBlock(block_name="t"))
+    CBDFunc.addBlock(ProductBlock(block_name="p"))
+    CBDFunc.addBlock(ConstantBlock(block_name="c", value=5.0))
+    CBDFunc.addConnection("t", "p") 
+    CBDFunc.addConnection("c", "p")
+    CBDFunc.addConnection("p", "OUT1")
+    return CBDFunc      
+      
+  def initializeFunc(self):
+    #f(t) = (t-2)^3  
+    CBDFunc = CBD("function", output_ports = ["OUT1"])
+    CBDFunc.addBlock(TimeBlock(block_name="t"))
+    CBDFunc.addBlock(ProductBlock(block_name="p"))
+    CBDFunc.addBlock(ProductBlock(block_name="p2"))
+    CBDFunc.addBlock(AdderBlock(block_name="a"))
+    CBDFunc.addBlock(ConstantBlock(block_name="c", value=-2.0))
+    CBDFunc.addConnection("t", "a") 
+    CBDFunc.addConnection("c", "a")
+    CBDFunc.addConnection("a", "p")
+    CBDFunc.addConnection("a", "p")
+    CBDFunc.addConnection("p", "p2")
+    CBDFunc.addConnection("a", "p2")
+    CBDFunc.addConnection("p2", "OUT1")
+    return CBDFunc  
+      
+  def initializeFunc2(self):
+    #f(t) = (t-2)^4
+    CBDFunc = CBD("function", output_ports = ["OUT1"])
+    CBDFunc.addBlock(TimeBlock(block_name="t"))
+    CBDFunc.addBlock(ProductBlock(block_name="p"))
+    CBDFunc.addBlock(ProductBlock(block_name="p2"))
+    CBDFunc.addBlock(ProductBlock(block_name="p3"))
+    CBDFunc.addBlock(AdderBlock(block_name="a"))
+    CBDFunc.addBlock(ConstantBlock(block_name="c", value=-2.0))
+    CBDFunc.addConnection("t", "a") 
+    CBDFunc.addConnection("c", "a")
+    CBDFunc.addConnection("a", "p")
+    CBDFunc.addConnection("a", "p")
+    CBDFunc.addConnection("p", "p2")
+    CBDFunc.addConnection("a", "p2")
+    CBDFunc.addConnection("p2", "p3")
+    CBDFunc.addConnection("a", "p3")
+    CBDFunc.addConnection("p3", "OUT1")
+    return CBDFunc      
+  
+  def initializeFuncInt(self):
+    #f(t) = 2*t  
+    CBDFunc = CBD("function", output_ports = ["OUT1"])
+    CBDFunc.addBlock(TimeBlock(block_name="t"))
+    CBDFunc.addBlock(ProductBlock(block_name="p"))
+    CBDFunc.addBlock(ConstantBlock(block_name="c", value=2.0))
+    CBDFunc.addConnection("t", "p") 
+    CBDFunc.addConnection("c", "p")
+    CBDFunc.addConnection("p", "OUT1")
+    return CBDFunc  
+     
+  def testDerivatorBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c3", value=1.0))
+    self.CBD.addBlock(ConstantBlock(block_name="zero", value=0.0))
+    CBDFunc = self.initializeFuncDerBas()
+    self.CBD.addBlock(CBDFunc) 
+    self.CBD.addBlock(DerivatorBlock(block_name="der"))
+    
+    self.CBD.addConnection("c3", "der", input_port_name="delta_t")
+    self.CBD.addConnection("zero", "der", input_port_name="IC")
+    self.CBD.addConnection("function", "der")
+    self._run(5)
+    self.assertEquals(self._getSignal("der"), [0.0]+[5.0]*4)    
+
+            
+  def testIntegratorBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=6.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=0.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c3", value=0.001))
+    self.CBD.addBlock(AdderBlock(block_name="a"))
+    self.CBD.addBlock(DelayBlock(block_name="d"))
+    
+    self.CBD.addBlock(IntegratorBlock(block_name="int"))
+    self.CBD.addConnection("c3", "int", input_port_name="delta_t")
+    self.CBD.addConnection("a", "int")
+    self.CBD.addConnection("c2", "int", input_port_name="IC")
+    
+    self.CBD.addConnection("c1", "a")
+    self.CBD.addConnection("d", "a")
+    self.CBD.addConnection("a", "d")
+    self.CBD.addConnection("c2", "d", input_port_name="IC")
+    self._run(NUM_DISCR_TIME_STEPS)
+    self.assertEquals(self._getSignal("int"), [0.0, 0.006, 0.018000000000000002, 0.036000000000000004, 0.060000000000000005])
+  
+  def testDelayBlock(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=5.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=3.0))
+    self.CBD.addBlock(DelayBlock(block_name="d"))
+    
+    self.CBD.addConnection("c2", "d")
+    self.CBD.addConnection("c1", "d", input_port_name="IC")
+    self._run(4)
+    self.assertEquals(self._getSignal("d"), [5.0, 3.0, 3.0, 3.0])
+
+  def testDelayBlock2(self):
+    self.CBD.addBlock(ConstantBlock(block_name="c1", value=1.0))
+    self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.0))
+    self.CBD.addBlock(DelayBlock(block_name="d"))
+    self.CBD.addBlock(AdderBlock(block_name="a"))
+
+    self.CBD.addConnection("c2", "a")
+    self.CBD.addConnection("d", "a")
+    self.CBD.addConnection("c1", "d", input_port_name="IC")
+    self.CBD.addConnection("a", "d")
+    self._run(5)
+    self.assertEquals(self._getSignal("d"), [1.0, 6.0, 11.0, 16.0, 21.0])
+      
+
+def suite():
+    """Returns a test suite containing all the test cases in this module."""
+    suite = unittest.makeSuite(BasicCBDTestCase)
+    
+    return unittest.TestSuite((suite))
+
+if __name__ == '__main__':
+    # When this module is executed from the command-line, run all its tests
+    unittest.main(verbosity=2)
+
+  
+  
+  
+  
+  
+  
+  
+  

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Test/flattenCBDTest.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+#
+# Unit tests for the flatten function on the CBD
+
+import unittest
+from CBDMultipleOutput.Source.CBD import *
+from basicCBDTest import BasicCBDTestCase
+
+class FlattenCBDTest(unittest.TestCase):
+	def setUp(self):
+		self.CBD = CBD("block_under_test")		
+		
+	def _run(self, num_steps=1, step = 1):
+		self.CBD.run(num_steps, step)			
+			
+	def _getSignal(self, blockname, output_port = None):
+		foundBlocks = [ block for block in self.CBD.getBlocks() if block.getBlockName() == blockname ]
+		
+		signal =  foundBlocks[0].getSignal(name_output = output_port)
+		
+		if len(foundBlocks) == 1:
+			return [x.value for x in signal]
+		else:
+			raise Exception("No single block with name " + blockname + " found")
+							
+	def testInterCBD(self):
+		CBDLittle1 = CBD("first_child", output_ports = ["outCBD1"])
+		CBDLittle2 = CBD("second_child", input_ports = ["inCBD2"])
+		
+		self.CBD.addBlock(CBDLittle1)
+		self.CBD.addBlock(CBDLittle2)
+		self.CBD.addConnection("first_child", "second_child", input_port_name = "inCBD2", output_port_name = "outCBD1") 
+
+		CBDLittle1.addBlock(ConstantBlock(block_name="c1", value=2.0))
+		CBDLittle1.addConnection("c1", "outCBD1")
+		
+		self.CBD.flatten()
+		self._run(5)
+		self.assertEquals(self._getSignal("second_child.inCBD2"), [2.0]*5)
+
+		
+	def testLinearStrongComponentWithMult(self):
+		CBDConstant1 = CBD("constantCBD1", output_ports = ["outConstant1"])
+		CBDConstant1.addBlock(ConstantBlock(block_name="c", value=3))
+		CBDConstant1.addConnection("c", "outConstant1")
+		
+		CBDConstant2 = CBD("constantCBD2", output_ports = ["outConstant2"])
+		CBDConstant2.addBlock(ConstantBlock(block_name="c", value=5))
+		CBDConstant2.addConnection("c", "outConstant2")
+		
+		CBDAdder = CBD("adderCBD", input_ports = ["in1Add", "in2Add"], output_ports = ["outAdd"])
+		CBDAdder.addBlock(AdderBlock(block_name="a"))
+		CBDAdder.addConnection("in1Add", "a")
+		CBDAdder.addConnection("in2Add", "a")
+		CBDAdder.addConnection("a", "outAdd")
+		
+		CBDProduct = CBD("productCBD", input_ports = ["in1Prod", "in2Prod"], output_ports = ["outProd"])
+		CBDProduct.addBlock(ProductBlock(block_name="p"))
+		CBDProduct.addConnection("in1Prod", "p")
+		CBDProduct.addConnection("in2Prod", "p")
+		CBDProduct.addConnection("p", "outProd")
+		
+		self.CBD.addBlock(CBDConstant1)
+		self.CBD.addBlock(CBDConstant2)
+		self.CBD.addBlock(CBDAdder)
+		self.CBD.addBlock(CBDProduct)
+		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name = "outConstant1")
+		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name = "outProd")
+		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name = "outAdd")
+		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name = "outConstant2")
+			
+		self.CBD.flatten()
+		self._run(5)
+		self.assertEquals(self._getSignal("adderCBD.outAdd"), [-0.75]*5)
+		self.assertEquals(self._getSignal("productCBD.outProd"), [-3.75]*5)
+		
+	def testLinearStrongComponentWithNeg(self):
+		CBDConstant1 = CBD("constantCBD1", output_ports = ["outConstant1"])
+		CBDConstant1.addBlock(ConstantBlock(block_name="c", value=5))
+		CBDConstant1.addConnection("c", "outConstant1")
+		
+		CBDConstant2 = CBD("constantCBD2", output_ports = ["outConstant2"])
+		CBDConstant2.addBlock(ConstantBlock(block_name="c", value=8))
+		CBDConstant2.addConnection("c", "outConstant2")
+		
+		CBDAdder1 = CBD("adder1CBD", input_ports = ["in1Add1", "in2Add1"], output_ports = ["outAdd1"])
+		CBDAdder1.addBlock(AdderBlock(block_name="a"))
+		CBDAdder1.addConnection("in1Add1", "a")
+		CBDAdder1.addConnection("in2Add1", "a")
+		CBDAdder1.addConnection("a", "outAdd1")
+		
+		CBDAdder2 = CBD("adder2CBD", input_ports = ["in1Add2", "in2Add2"], output_ports = ["outAdd2"])
+		CBDAdder2.addBlock(AdderBlock(block_name="a"))
+		CBDAdder2.addConnection("in1Add2", "a")
+		CBDAdder2.addConnection("in2Add2", "a")
+		CBDAdder2.addConnection("a", "outAdd2")
+		
+		CBDNegator = CBD("negatorCBD", input_ports = ["inNeg"], output_ports = ["outNeg"])
+		CBDNegator.addBlock(NegatorBlock(block_name="n"))
+		CBDNegator.addConnection("inNeg", "n")
+		CBDNegator.addConnection("n", "outNeg")
+		
+		self.CBD.addBlock(CBDConstant1)
+		self.CBD.addBlock(CBDConstant2)
+		self.CBD.addBlock(CBDAdder1)
+		self.CBD.addBlock(CBDAdder2)
+		self.CBD.addBlock(CBDNegator)
+		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name = "outConstant1")
+		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name = "outAdd2")
+		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name = "outConstant2")
+		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name = "outNeg")
+		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name = "outAdd1")
+		
+		self.CBD.flatten()
+		self._run(5)
+		self.assertEquals(self._getSignal("adder1CBD.outAdd1"), [6.5]*5)
+		self.assertEquals(self._getSignal("adder2CBD.outAdd2"), [1.5]*5)	
+		self.assertEquals(self._getSignal("negatorCBD.outNeg"), [-6.5]*5)		
+		
+	def testInterInterCBD(self):
+		"""
+							  +--------------------------------------------+
+				   +----+     |                    +------+                |
+				   |    |+--->|+------------------>|      |                |
+				   |  2 |     ||                   |  +   +--------------->+-------+
+		+----+     +----+     || +---------+   +-->|      |                |       |
+		|    |                |+>|         |   |   +------+                |       v
+		| 5  |   +------+     |  |         |   |                           |    +------+
+		+----++->|      |     |  |    *    |   |                           |    |      |
+				 |  +   |     |  |         |   |                           |    |  +   +------> 0
+		+----++->|      |+--->|+>|         |   |                           |    |      |
+		| 2  |   +------+     |  +--+------+   +--------------+            |    +------+
+		|    |                |     |                         |   +-----+  |       ^
+		+----+                |     |   +--------------------+|   |     |  |       |
+							  |     |   |     +-----+        ||   | 12  +->+-------+
+							  |     |   |     |     |        ||   |     |  |
+							  |     +-->+---->|  -  +------->++   +-----+  |
+							  |         |     |     |        |             |
+							  |         |     +-----+        |             |
+							  |         +--------------------+             |
+							  +--------------------------------------------+
+		"""		  
+		CBDLittle1 = CBD("first_child", input_ports = ["in1CBD1", "in2CBD1"], output_ports = ["out1CBD1", "out2CBD1"])
+		CBDLittle2 = CBD("first_child_of_first_child", input_ports = ["inCBD2"], output_ports = ["outCBD2"])
+		
+		self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.0))
+		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.0))
+		self.CBD.addBlock(ConstantBlock(block_name="c3", value=2.0))
+		self.CBD.addBlock(AdderBlock(block_name="a"))
+		self.CBD.addBlock(AdderBlock(block_name="a2"))
+		self.CBD.addBlock(CBDLittle1)
+		self.CBD.addConnection("c3", "a")
+		self.CBD.addConnection("c2", "a")
+		self.CBD.addConnection("c1", "first_child", input_port_name = "in1CBD1")
+		self.CBD.addConnection("a", "first_child", input_port_name = "in2CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name = "out1CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name = "out2CBD1")
+				
+		CBDLittle1.addBlock(ProductBlock(block_name="p"))
+		CBDLittle1.addBlock(AdderBlock(block_name="a"))
+		CBDLittle1.addBlock(CBDLittle2)
+		CBDLittle1.addBlock(ConstantBlock(block_name="c", value=12.0))
+		CBDLittle1.addConnection("in1CBD1", "p")
+		CBDLittle1.addConnection("in2CBD1", "p")
+		CBDLittle1.addConnection("in1CBD1", "a")
+		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name = "outCBD2")
+		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name = "inCBD2")
+		CBDLittle1.addConnection("c", "out1CBD1")
+		CBDLittle1.addConnection("a", "out2CBD1")
+		
+		CBDLittle2.addBlock(NegatorBlock(block_name="n"))
+		CBDLittle2.addConnection("inCBD2", "n")
+		CBDLittle2.addConnection("n", "outCBD2")
+		
+		self.CBD.flatten()
+		self._run(5)		
+		self.assertEquals(self._getSignal("first_child.p"), [14.0]*5)
+		self.assertEquals(self._getSignal("first_child.first_child_of_first_child.n"), [-14.0]*5)
+		self.assertEquals(self._getSignal("first_child.in1CBD1"), [2.0]*5)
+		self.assertEquals(self._getSignal("first_child.a"), [-12.0]*5)		
+		self.assertEquals(self._getSignal("a2"), [0.0]*5)
+		
+		
+def suite():
+    """Returns a suite containing all the test cases in this module."""
+    suite1 = unittest.makeSuite(BasicCBDTestCase)
+    
+    return unittest.TestSuite((suite1))
+
+if __name__ == '__main__':
+    # When this module is executed from the command-line, run all its tests
+    unittest.main()
+
+	
+	
+	
+	
+	
+	
+	
+	

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Test/hierarchyCBDTest.py

@@ -0,0 +1,201 @@
+#!/usr/bin/env python
+#
+# Unit tests for the hierarchy functionality of the CBD
+
+import unittest
+from CBDMultipleOutput.Source.CBD import *
+from basicCBDTest import BasicCBDTestCase
+
+class HierarchyCBDTest(unittest.TestCase):
+	def setUp(self):
+		self.CBD = CBD("block_under_test")		
+		
+	def _run(self, num_steps=1, step = 1):
+		self.CBD.run(num_steps, step)			
+			
+	def _getSignal(self, blockname, output_port = None):
+		foundBlocks = [ block for block in self.CBD.getBlocks() if block.getBlockName() == blockname ]
+		
+		signal =  foundBlocks[0].getSignal(name_output = output_port)
+		
+		if len(foundBlocks) == 1:
+			return [x.value for x in signal]
+		else:
+			raise Exception("No single block with name " + blockname + " found")			
+		
+	def testInterCBD(self):		
+		CBDLittle1 = CBD("first_child", output_ports = ["outCBD1"])
+		CBDLittle1.addBlock(ConstantBlock(block_name="c1", value=2.0))
+		CBDLittle1.addConnection("c1", "outCBD1")
+		
+		CBDLittle2 = CBD("second_child", input_ports = ["inCBD2"], output_ports = ["outCBD2"])
+		CBDLittle2.addBlock(NegatorBlock(block_name="n"))
+		CBDLittle2.addConnection("inCBD2", "n")
+		CBDLittle2.addConnection("n", "outCBD2")
+		
+		self.CBD.addBlock(CBDLittle1)
+		self.CBD.addBlock(CBDLittle2)
+		neg = NegatorBlock(block_name="n")
+		self.CBD.addBlock(neg)
+		self.CBD.addConnection("first_child", "second_child", input_port_name = "inCBD2", output_port_name = "outCBD1") 
+		self.CBD.addConnection("second_child", "n", output_port_name = "outCBD2") 
+
+		self._run(5)
+		self.assertEquals(self._getSignal("n"), [2.0]*5)
+
+		
+	def testLinearStrongComponentWithMult(self):
+		CBDConstant1 = CBD("constantCBD1", output_ports = ["outConstant1"])
+		CBDConstant1.addBlock(ConstantBlock(block_name="c", value=3))
+		CBDConstant1.addConnection("c", "outConstant1")
+		
+		CBDConstant2 = CBD("constantCBD2", output_ports = ["outConstant2"])
+		CBDConstant2.addBlock(ConstantBlock(block_name="c", value=5))
+		CBDConstant2.addConnection("c", "outConstant2")
+		
+		CBDAdder = CBD("adderCBD", input_ports = ["in1Add", "in2Add"], output_ports = ["outAdd"])
+		CBDAdder.addBlock(AdderBlock(block_name="a"))
+		CBDAdder.addConnection("in1Add", "a")
+		CBDAdder.addConnection("in2Add", "a")
+		CBDAdder.addConnection("a", "outAdd")
+		
+		CBDProduct = CBD("productCBD", input_ports = ["in1Prod", "in2Prod"], output_ports = ["outProd"])
+		CBDProduct.addBlock(ProductBlock(block_name="p"))
+		CBDProduct.addConnection("in1Prod", "p")
+		CBDProduct.addConnection("in2Prod", "p")
+		CBDProduct.addConnection("p", "outProd")
+		
+		self.CBD.addBlock(CBDConstant1)
+		self.CBD.addBlock(CBDConstant2)
+		self.CBD.addBlock(CBDAdder)
+		self.CBD.addBlock(CBDProduct)
+		self.CBD.addConnection("constantCBD1", "adderCBD", input_port_name="in1Add", output_port_name = "outConstant1")
+		self.CBD.addConnection("productCBD", "adderCBD", input_port_name="in2Add", output_port_name = "outProd")
+		self.CBD.addConnection("adderCBD", "productCBD", input_port_name="in1Prod", output_port_name = "outAdd")
+		self.CBD.addConnection("constantCBD2", "productCBD", input_port_name="in2Prod", output_port_name = "outConstant2")
+
+		self._run(5)
+		self.assertEquals(self._getSignal("adderCBD", output_port = "outAdd"), [-0.75]*5)
+		self.assertEquals(self._getSignal("productCBD", output_port = "outProd"), [-3.75]*5)	
+		
+	def testLinearStrongComponentWithNeg(self):
+		CBDConstant1 = CBD("constantCBD1", output_ports = ["outConstant1"])
+		CBDConstant1.addBlock(ConstantBlock(block_name="c", value=5))
+		CBDConstant1.addConnection("c", "outConstant1")
+		
+		CBDConstant2 = CBD("constantCBD2", output_ports = ["outConstant2"])
+		CBDConstant2.addBlock(ConstantBlock(block_name="c", value=8))
+		CBDConstant2.addConnection("c", "outConstant2")
+		
+		CBDAdder1 = CBD("adder1CBD", input_ports = ["in1Add1", "in2Add1"], output_ports = ["outAdd1"])
+		CBDAdder1.addBlock(AdderBlock(block_name="a"))
+		CBDAdder1.addConnection("in1Add1", "a")
+		CBDAdder1.addConnection("in2Add1", "a")
+		CBDAdder1.addConnection("a", "outAdd1")
+		
+		CBDAdder2 = CBD("adder2CBD", input_ports = ["in1Add2", "in2Add2"], output_ports = ["outAdd2"])
+		CBDAdder2.addBlock(AdderBlock(block_name="a"))
+		CBDAdder2.addConnection("in1Add2", "a")
+		CBDAdder2.addConnection("in2Add2", "a")
+		CBDAdder2.addConnection("a", "outAdd2")
+		
+		CBDNegator = CBD("negatorCBD", input_ports = ["inNeg"], output_ports = ["outNeg"])
+		CBDNegator.addBlock(NegatorBlock(block_name="n"))
+		CBDNegator.addConnection("inNeg", "n")
+		CBDNegator.addConnection("n", "outNeg")
+		
+		self.CBD.addBlock(CBDConstant1)
+		self.CBD.addBlock(CBDConstant2)
+		self.CBD.addBlock(CBDAdder1)
+		self.CBD.addBlock(CBDAdder2)
+		self.CBD.addBlock(CBDNegator)
+		self.CBD.addConnection("constantCBD1", "adder1CBD", input_port_name="in1Add1", output_port_name = "outConstant1")
+		self.CBD.addConnection("adder2CBD", "adder1CBD", input_port_name="in2Add1", output_port_name = "outAdd2")
+		self.CBD.addConnection("constantCBD2", "adder2CBD", input_port_name="in1Add2", output_port_name = "outConstant2")
+		self.CBD.addConnection("negatorCBD", "adder2CBD", input_port_name="in2Add2", output_port_name = "outNeg")
+		self.CBD.addConnection("adder1CBD", "negatorCBD", input_port_name="inNeg", output_port_name = "outAdd1")
+
+		self._run(5)
+		self.assertEquals(self._getSignal("adder1CBD", output_port = "outAdd1"), [6.5]*5)
+		self.assertEquals(self._getSignal("adder2CBD", output_port = "outAdd2"), [1.5]*5)	
+		self.assertEquals(self._getSignal("negatorCBD", output_port = "outNeg"), [-6.5]*5)	
+		
+	def testInterInterCBD(self):
+		"""
+							  +--------------------------------------------+
+				   +----+     |                    +------+                |
+				   |    |+--->|+------------------>|      |                |
+				   |  2 |     ||                   |  +   +--------------->+-------+
+		+----+     +----+     || +---------+   +-->|      |                |       |
+		|    |                |+>|         |   |   +------+                |       v
+		| 5  |   +------+     |  |         |   |                           |    +------+
+		+----++->|      |     |  |    *    |   |                           |    |      |
+				 |  +   |     |  |         |   |                           |    |  +   +------> 0
+		+----++->|      |+--->|+>|         |   |                           |    |      |
+		| 2  |   +------+     |  +--+------+   +--------------+            |    +------+
+		|    |                |     |                         |   +-----+  |       ^
+		+----+                |     |   +--------------------+|   |     |  |       |
+							  |     |   |     +-----+        ||   | 12  +->+-------+
+							  |     |   |     |     |        ||   |     |  |
+							  |     +-->+---->|  -  +------->++   +-----+  |
+							  |         |     |     |        |             |
+							  |         |     +-----+        |             |
+							  |         +--------------------+             |
+							  +--------------------------------------------+
+		"""		  
+		CBDLittle1 = CBD("first_child", input_ports = ["in1CBD1", "in2CBD1"], output_ports = ["out1CBD1", "out2CBD1"])
+		CBDLittle2 = CBD("first_child_of_first_child", input_ports = ["inCBD2"], output_ports = ["outCBD2"])
+		
+		self.CBD.addBlock(ConstantBlock(block_name="c1", value=2.0))
+		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.0))
+		self.CBD.addBlock(ConstantBlock(block_name="c3", value=2.0))
+		self.CBD.addBlock(AdderBlock(block_name="a"))
+		self.CBD.addBlock(AdderBlock(block_name="a2"))
+		self.CBD.addBlock(CBDLittle1)
+		self.CBD.addConnection("c3", "a")
+		self.CBD.addConnection("c2", "a")
+		self.CBD.addConnection("c1", "first_child", input_port_name = "in1CBD1")
+		self.CBD.addConnection("a", "first_child", input_port_name = "in2CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name = "out1CBD1")
+		self.CBD.addConnection("first_child", "a2", output_port_name = "out2CBD1")
+				
+		CBDLittle1.addBlock(ProductBlock(block_name="p"))
+		CBDLittle1.addBlock(AdderBlock(block_name="a"))
+		CBDLittle1.addBlock(CBDLittle2)
+		CBDLittle1.addBlock(ConstantBlock(block_name="c", value=12.0))
+		CBDLittle1.addConnection("in1CBD1", "p")
+		CBDLittle1.addConnection("in2CBD1", "p")
+		CBDLittle1.addConnection("in1CBD1", "a")
+		CBDLittle1.addConnection("first_child_of_first_child", "a", output_port_name = "outCBD2")
+		CBDLittle1.addConnection("p", "first_child_of_first_child", input_port_name = "inCBD2")
+		CBDLittle1.addConnection("c", "out1CBD1")
+		CBDLittle1.addConnection("a", "out2CBD1")
+		
+		CBDLittle2.addBlock(NegatorBlock(block_name="n"))
+		CBDLittle2.addConnection("inCBD2", "n")
+		CBDLittle2.addConnection("n", "outCBD2")
+		
+		self._run(5)		
+		self.assertEquals(self._getSignal("first_child", output_port = "p"), [14.0]*5)
+		self.assertEquals(self._getSignal("first_child", output_port = "in1CBD1"), [2.0]*5)
+		self.assertEquals(self._getSignal("first_child", output_port = "a"), [-12.0]*5)		
+		self.assertEquals(self._getSignal("a2"), [0.0]*5)	
+		
+def suite():
+    """Returns a suite containing all the test cases in this module."""
+    suite1 = unittest.makeSuite(BasicCBDTestCase)
+    
+    return unittest.TestSuite((suite1))
+
+if __name__ == '__main__':
+    # When this module is executed from the command-line, run all its tests
+    unittest.main()
+
+	
+	
+	
+	
+	
+	
+	
+	

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/Test/sortedGraphCBDTest.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+#
+# Unit tests for the sorting of a CBD.
+
+import unittest
+from CBDMultipleOutput.Source.CBD import *
+from basicCBDTest import BasicCBDTestCase
+
+class SortedGraphCBDTest(unittest.TestCase):
+	def setUp(self):
+		self.CBD = CBD("block_under_test")		
+		
+	def _run(self, num_steps=1):
+		self.CBD.run(num_steps)			
+	
+	def testSortedGraph(self):
+		CBDNegator = CBD("negatorCBD", input_ports = ["inNegator"], output_ports = ["outNegator"])
+		negCbd = NegatorBlock(block_name="nC")
+		CBDNegator.addBlock(negCbd)
+		CBDNegator.addConnection("inNegator", "nC")	
+		CBDNegator.addConnection("nC", "outNegator")	
+		
+		const = ConstantBlock(block_name="c", value=5.5)
+		self.CBD.addBlock(const)
+		neg = NegatorBlock(block_name="n")
+		self.CBD.addBlock(neg)
+		self.CBD.addBlock(CBDNegator)
+		self.CBD.addConnection("negatorCBD", "n", output_port_name = "outNegator")
+		self.CBD.addConnection("c", "negatorCBD", input_port_name = "inNegator")
+		
+		depGraph = self.CBD._CBD__createDepGraph(0)
+		sortedGraph = depGraph.getStrongComponents()
+		
+		self.assertEquals(len(sortedGraph), 5)
+		self.assertEquals(sortedGraph[0][0], const)
+		self.assertEquals(sortedGraph[2][0], negCbd)
+		self.assertEquals(sortedGraph[4][0], neg)
+		
+	def testSortedGraph2(self):
+		CBDAdder = CBD("adderCBD", input_ports = ["in1", "in2"], output_ports = ["outAdd"])
+		addCBD = AdderBlock(block_name="aC")
+		CBDAdder.addBlock(addCBD)
+		CBDAdder.addConnection("in1", "aC")	
+		CBDAdder.addConnection("in2", "aC")	
+		CBDAdder.addConnection("aC", "outAdd")	
+		
+		const1 = ConstantBlock(block_name="c1", value=5.5)
+		const2 = ConstantBlock(block_name="c2", value=4.5)
+		self.CBD.addBlock(const1)
+		self.CBD.addBlock(const2)
+		neg = NegatorBlock(block_name="n")
+		self.CBD.addBlock(neg)
+		self.CBD.addBlock(CBDAdder)
+		self.CBD.addConnection("adderCBD", "n", output_port_name = "outAdd")
+		self.CBD.addConnection("c1", "adderCBD", input_port_name = "in1")
+		self.CBD.addConnection("c2", "adderCBD", input_port_name = "in2")
+		
+		depGraph = self.CBD._CBD__createDepGraph(0)
+		sortedGraph = depGraph.getStrongComponents()
+		comps = [ x[0] for x in sortedGraph ]
+		
+		tester = self
+		ag = lambda x,y: tester.assertTrue(comps.index(x) > comps.index(y))
+		
+		self.assertEquals(len(sortedGraph), 7)
+		ag(addCBD, const1)
+		ag(addCBD, const2)
+		ag(neg, addCBD)
+		
+	def testSortedGraph3(self):	
+		CBDNegator = CBD("negatorCBD", input_ports = ["inNegator"], output_ports = ["outNegator", "outInverter"])
+		negCbd = NegatorBlock(block_name="nC")
+		invCBD = InverterBlock(block_name="iC")
+		CBDNegator.addBlock(negCbd)
+		CBDNegator.addBlock(invCBD)
+		CBDNegator.addConnection("inNegator", "nC")	
+		CBDNegator.addConnection("inNegator", "iC")	
+		CBDNegator.addConnection("nC", "outNegator")	
+		CBDNegator.addConnection("iC", "outInverter")	
+		
+		const = ConstantBlock(block_name="c", value=5.5)
+		self.CBD.addBlock(const)
+		add = AdderBlock(block_name="a")
+		self.CBD.addBlock(add)
+		self.CBD.addBlock(CBDNegator)
+		self.CBD.addConnection("negatorCBD", "a", output_port_name = "outNegator")
+		self.CBD.addConnection("negatorCBD", "a", output_port_name = "outInverter")
+		self.CBD.addConnection("c", "negatorCBD", input_port_name = "inNegator")
+		
+		depGraph = self.CBD._CBD__createDepGraph(0)
+		sortedGraph = depGraph.getStrongComponents()
+		comps = [ x[0] for x in sortedGraph ]
+		
+		tester = self
+		ag = lambda x,y: tester.assertTrue(comps.index(x) > comps.index(y))
+
+		self.assertEquals(len(sortedGraph), 7)
+		ag(negCbd, const)
+		ag(invCBD, const)
+		ag(add, negCbd)
+		ag(add, invCBD)
+		
+	def testSortedGraph4(self):
+		CBDStrong = CBD("strongCBD", input_ports = ["inC1", "inC2"], output_ports = [])
+		CBDStrong.addBlock(AdderBlock(block_name="a1"))
+		CBDStrong.addBlock(AdderBlock(block_name="a3"))
+		CBDStrong.addBlock(AdderBlock(block_name="a2"))
+		CBDStrong.addConnection("a3", "a1")		
+		CBDStrong.addConnection("a1", "a3")
+		CBDStrong.addConnection("a2", "a3")
+		CBDStrong.addConnection("inC1", "a1")
+		CBDStrong.addConnection("inC2", "a2")
+		CBDStrong.addConnection("a3", "a2")
+		
+		self.CBD.addBlock(CBDStrong)
+		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.5))
+		self.CBD.addBlock(ConstantBlock(block_name="c1", value=-5))
+		self.CBD.addConnection("c1", "strongCBD", input_port_name = "inC1")
+		self.CBD.addConnection("c2", "strongCBD", input_port_name = "inC2")
+		
+		depGraph = self.CBD._CBD__createDepGraph(0)
+		sortedGraph = depGraph.getStrongComponents()
+				
+		self.assertEquals(len(sortedGraph), 5)
+		self.assertEquals(len(sortedGraph[4]), 3)
+		
+	def testSortedGraph5(self):
+		CBDStrong = CBD("strongCBD", input_ports = ["inC1", "inC2", "inA"], output_ports = ["out1", "out2"])
+		CBDStrong.addBlock(AdderBlock(block_name="a1"))
+		CBDStrong.addBlock(AdderBlock(block_name="a2"))
+		CBDStrong.addConnection("inA", "a1")		
+		CBDStrong.addConnection("a1", "out1")
+		CBDStrong.addConnection("a2", "out2")
+		CBDStrong.addConnection("inC1", "a1")
+		CBDStrong.addConnection("inC2", "a2")
+		CBDStrong.addConnection("inA", "a2")
+		
+		self.CBD.addBlock(CBDStrong)
+		self.CBD.addBlock(AdderBlock(block_name="a3"))
+		self.CBD.addBlock(ConstantBlock(block_name="c2", value=5.5))
+		self.CBD.addBlock(ConstantBlock(block_name="c1", value=-5))
+		self.CBD.addConnection("c1", "strongCBD", input_port_name = "inC1")
+		self.CBD.addConnection("c2", "strongCBD", input_port_name = "inC2")
+		self.CBD.addConnection("a3", "strongCBD", input_port_name = "inA")
+		self.CBD.addConnection("strongCBD", "a3", output_port_name = "out1")
+		self.CBD.addConnection("strongCBD", "a3", output_port_name = "out2")
+		
+		depGraph = self.CBD._CBD__createDepGraph(0)
+		sortedGraph = depGraph.getStrongComponents()
+				
+		self.assertEquals(len(sortedGraph), 5)
+		self.assertEquals(len(sortedGraph[4]), 6)	
+		
+		
+def suite():
+    """Returns a suite containing all the test cases in this module."""
+    suite1 = unittest.makeSuite(BasicCBDTestCase)
+    
+    return unittest.TestSuite((suite1))
+
+if __name__ == '__main__':
+    # When this module is executed from the command-line, run all its tests
+    unittest.main()
+
+	
+	
+	
+	
+	
+	
+	
+	

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/models/EvenNumbersCBD.py

@@ -0,0 +1,80 @@
+#!/usr/bin/env python
+from bokeh.plotting import figure, output_file, show
+from CBDMultipleOutput.Source.CBD import *
+from CBDMultipleOutput.Source.CBDDraw import draw
+
+
+class Counter(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                    block_name, 
+                    input_ports=[], 
+                    output_ports=["OutCount"])
+        
+        self.addBlock(DelayBlock(block_name="delay"))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(ConstantBlock(block_name="one", value=1.0))
+        
+        self.addConnection("zero", "delay", 
+                            input_port_name="IC")
+        self.addConnection("delay", "OutCount")
+        self.addConnection("delay", "sum")
+        self.addConnection("sum", "delay", input_port_name="IN1")
+        self.addConnection("one", "sum")
+        
+class Double(CBD):        
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                     block_name, 
+                     input_ports=["InNumber"], 
+                     output_ports=["OutDouble"])
+        self.addBlock(ProductBlock(block_name="mult"))
+        self.addBlock(ConstantBlock(block_name="two", value=2.0))
+        
+        self.addConnection("InNumber", "mult")
+        self.addConnection("two", "mult")
+        self.addConnection("mult", "OutDouble")
+    
+    
+class EvenNumberGen(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, 
+                     block_name, 
+                     input_ports=[],
+                     output_ports=["OutEven"])
+        
+        self.addBlock(Counter(block_name="counter"))
+        self.addBlock(Double(block_name="double"))
+        
+        self.addConnection("counter", "double", 
+                           input_port_name="InNumber",
+                           output_port_name="OutCount")
+        self.addConnection("double", "OutEven",
+                           output_port_name="OutDouble")
+        
+
+
+if __name__ == "__main__":
+    
+    cbd = EvenNumberGen("number_gen")
+    draw(cbd, "number_gen.dot")
+    draw(cbd.getBlockByName("counter"), "counter.dot")
+    cbd.run(10)
+    
+    times = []
+    output = []
+    
+    for timeValuePair in cbd.getSignal("OutEven"):
+        times.append(timeValuePair.time)
+        output.append(timeValuePair.value)
+                
+    #Plot
+    output_file("./number_gen.html", title="Even Numbers")
+    p = figure(title="Even Numbers", x_axis_label='time', y_axis_label='N')
+    p.circle(x=times, y=output, legend="Even numbers")
+    show(p)
+
+
+
+

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/models/HarmonicOscilator.py

@@ -0,0 +1,21 @@
+from CBDMultipleOutput.Source.CBD import *
+
+class CircleCBDDerivative(CBD):
+    def __init__(self, blockName, delta_t):
+        CBD.__init__(self,blockName, [], [])
+        self.delta=delta_t;
+        self.addBlock(ConstantBlock(block_name="one", value=1.0))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(ConstantBlock(block_name="delta", value=self.delta))
+        self.addBlock(NegatorBlock(block_name="neg"))
+        self.addBlock(DerivatorBlock(block_name="derxv"))
+        self.addBlock(DerivatorBlock(block_name="derva"))
+        
+        self.addConnection("delta", "derxv",  input_port_name="delta_t")
+        self.addConnection("delta", "derva",  input_port_name="delta_t")
+        self.addConnection("zero", "derva",  input_port_name="IC")
+        self.addConnection("one", "derxv",  input_port_name="IC")
+        self.addConnection("derva", "neg")
+        self.addConnection("neg", "derxv")
+        self.addConnection("derxv", "derva")
+        

fsa_cbd_composition/cbdsimulator/CBDMultipleOutput/models/TrainControlCBD.py

@@ -0,0 +1,300 @@
+#!/usr/bin/env python
+from CBDMultipleOutput.Source.CBD import *
+
+DELTA = 0.1
+MASS_PERSON = 73
+MASS_TRAIN = 6000
+K = 300
+C = 150
+
+
+
+class TrainControlCBD(CBD):
+    def __init__(self, block_name, kp, ki, kd):
+        CBD.__init__(self, block_name)
+        self.addBlock(FixedTimeCBD(block_name="time"))
+        self.addBlock(LookUpBlockFixed(block_name="computer"))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(NegatorBlock(block_name="neg"))
+        self.addBlock(TrainPIDController("controller", kp, ki, kd))
+        self.addBlock(TrainPerson(block_name="plant"))
+        self.addBlock(CostFunctionCBD(block_name="cost"))
+        
+        # the connections follow the topological sort.
+        self.addConnection("time", "computer", 
+                            input_port_name="IN1", output_port_name="OutTime")
+        self.addConnection("time", "plant", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("time", "controller", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("computer", "sum", 
+                            input_port_name="IN1", output_port_name="OUT1")
+        self.addConnection("plant", "neg", 
+                            input_port_name="IN1", output_port_name="OutVTrain")
+        self.addConnection("neg", "sum", 
+                            input_port_name="IN2", output_port_name="OUT1")
+        self.addConnection("sum", "controller", 
+                            input_port_name="InError", output_port_name="OUT1")
+        self.addConnection("controller", "plant", 
+                            input_port_name="InTraction", output_port_name="OutTraction")
+        self.addConnection("sum", "cost", 
+                            input_port_name="InError")
+        self.addConnection("time", "cost", 
+                            input_port_name="InDelta", output_port_name="OutDelta")
+        self.addConnection("plant", "cost", 
+                            input_port_name="InXPerson", output_port_name="OutXPerson")
+        
+        
+
+class CostFunctionCBD(CBD):        
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InError","InDelta","InXPerson"], ["OutCost"])
+        self.addBlock(ABSBlock(block_name="abs"))
+        self.addBlock(ABSBlock(block_name="absError"))
+        self.addBlock(IntegratorBlock(block_name="integral"))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AboveThresholdBlock(block_name="above04", threshold=0.4))
+        self.addBlock(StopSimulationBlock(block_name="stop"))
+        
+        self.addConnection("InError", "absError")
+        self.addConnection("absError", "integral", input_port_name="IN1")
+        self.addConnection("InDelta", "integral", input_port_name="delta_t")
+        self.addConnection("zero", "integral", input_port_name="IC")
+        self.addConnection("integral", "OutCost")
+        self.addConnection("InXPerson", "abs")
+        self.addConnection("abs", "above04")
+        self.addConnection("above04", "stop")
+        
+
+class ABSBlock(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+
+    def compute(self, curIteration):
+        self.appendToSignal(abs(self.getInputSignal(curIteration).value))
+
+class LookUpBlockFixed(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+        
+    def compute(self, curIteration):
+        currentTime = self.getInputSignal(curIteration, "IN1").value
+        if currentTime < 0:
+            result = 0
+        elif currentTime < 160:
+            result = 14
+        elif currentTime < 200:
+            result = 2
+        elif currentTime < 260:
+            result = 15
+        else:
+            result = 0
+        
+        self.appendToSignal(result)
+
+
+
+class AboveThresholdBlock(BaseBlock):
+    def __init__(self, block_name, threshold):
+        BaseBlock.__init__(self, block_name, ["IN1"], ["OUT1"])
+        self.threshold = threshold
+
+    def compute(self, curIteration):
+        self.appendToSignal(1.0 if self.getInputSignal(curIteration).value > self.threshold else -1.0)
+
+
+
+class StopSimulationBlock(BaseBlock):
+    def __init__(self, block_name):
+        BaseBlock.__init__(self, block_name, ["IN1"], [])
+
+    def compute(self, curIteration):
+        inSignalValue = self.getInputSignal(curIteration).value
+        if inSignalValue > 0.0:
+            raise StopSimulationException()
+        
+
+class StopSimulationException(Exception):
+    pass
+        
+class FixedTimeCBD(CBD):        
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, [], ["OutTime", "OutDelta"])
+        self.addBlock(ConstantBlock(block_name="delta", value=DELTA))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(DelayBlock(block_name="delay"))
+        
+        self.addConnection("delta", "OutDelta")
+        self.addConnection("delay", "OutTime")
+        self.addConnection("delay", "sum")
+        self.addConnection("delta", "sum")
+        self.addConnection("sum", "delay")
+        self.addConnection("zero", "delay",
+                            input_port_name="IC")
+    
+
+class TrainPIDController(CBD):
+    def __init__(self, block_name, kp, ki, kd):
+        CBD.__init__(self, block_name, ["InError","InDelta"],["OutTraction"])
+        self.addBlock(IntegratorBlock(block_name="integral"))
+        self.addBlock(DerivatorBlock(block_name="derivative"))
+        self.addBlock(ConstantBlock(block_name="Kp", value=kp))
+        self.addBlock(ProductBlock(block_name="multKp"))
+        self.addBlock(ConstantBlock(block_name="Ki", value=ki))
+        self.addBlock(ProductBlock(block_name="multKi"))
+        self.addBlock(ConstantBlock(block_name="Kd", value=kd))
+        self.addBlock(ProductBlock(block_name="multKd"))
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AdderBlock(block_name="sum1"))
+        self.addBlock(AdderBlock(block_name="sum2"))
+        
+        self.addConnection("InError", "multKp")
+        self.addConnection("Kp", "multKp")
+        self.addConnection("InError", "integral")
+        self.addConnection("InError", "derivative")
+        self.addConnection("InDelta", "derivative", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral", 
+                            input_port_name="delta_t")
+        self.addConnection("zero", "derivative", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral", 
+                            input_port_name="IC")
+        self.addConnection("integral", "multKi")
+        self.addConnection("Ki", "multKi")
+        self.addConnection("derivative", "multKd")
+        self.addConnection("Kd", "multKd")
+        self.addConnection("multKd", "sum1")
+        self.addConnection("multKi", "sum1")
+        self.addConnection("sum1", "sum2")
+        self.addConnection("multKp", "sum2")
+        self.addConnection("sum2", "OutTraction")
+        
+        
+class TrainPerson(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction","InDelta"],["OutVTrain", "OutXPerson", "OutATrain"])
+        self.addBlock(ConstantBlock(block_name="zero", value=0.0))
+        self.addBlock(AccelerationPerson(block_name="accelerationPerson"))
+        self.addBlock(AccelerationTrain(block_name="accelerationTrain"))
+        self.addBlock(IntegratorBlock(block_name="integral_person_a_v"))
+        self.addBlock(IntegratorBlock(block_name="integral_person_v_x"))
+        self.addBlock(IntegratorBlock(block_name="integral_train_a_v"))
+        
+        self.addConnection("zero", "integral_person_a_v", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral_person_v_x", 
+                            input_port_name="IC")
+        self.addConnection("zero", "integral_train_a_v", 
+                            input_port_name="IC")
+        
+        self.addConnection("InDelta", "integral_person_a_v", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral_person_v_x", 
+                            input_port_name="delta_t")
+        self.addConnection("InDelta", "integral_train_a_v", 
+                            input_port_name="delta_t")
+        
+        self.addConnection("InTraction", "accelerationPerson", 
+                            input_port_name="InTraction")
+        self.addConnection("InTraction", "accelerationTrain", 
+                            input_port_name="InTraction")
+        
+        self.addConnection("accelerationPerson", "integral_person_a_v", 
+                            input_port_name="IN1", output_port_name="OutAPerson")
+        self.addConnection("integral_person_a_v", "accelerationPerson", 
+                            input_port_name="InVPerson", output_port_name="OUT1")
+        self.addConnection("integral_person_a_v", "integral_person_v_x", 
+                            input_port_name="IN1", output_port_name="OUT1")
+        self.addConnection("integral_person_v_x", "accelerationPerson", 
+                            input_port_name="InXPerson", output_port_name="OUT1")
+        
+        self.addConnection("accelerationTrain", "integral_train_a_v", 
+                            input_port_name="IN1", output_port_name="OutATrain")
+        
+        self.addConnection("integral_train_a_v", "OutVTrain")
+        
+        self.addConnection("integral_person_v_x", "OutXPerson")
+        
+        self.addConnection("accelerationTrain", "OutATrain", input_port_name=None, output_port_name="OutATrain")
+        
+        
+        
+class AccelerationPerson(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction","InVPerson","InXPerson"],["OutAPerson"])
+        self.addBlock(ConstantBlock(block_name="m_train", value=MASS_TRAIN))
+        self.addBlock(ConstantBlock(block_name="m_person", value=MASS_PERSON))
+        self.addBlock(ConstantBlock(block_name="c", value=C))
+        self.addBlock(ConstantBlock(block_name="k", value=K))
+        self.addBlock(AdderBlock(block_name="sum_masses"))
+        self.addBlock(InverterBlock(block_name="inv_sum_masses"))
+        self.addBlock(ProductBlock(block_name="mult_inv_sum_masses"))
+        self.addBlock(ProductBlock(block_name="mult_mult_inv_sum_masses"))
+        self.addBlock(InverterBlock(block_name="inv_mperson"))
+        self.addBlock(NegatorBlock(block_name="neg_mult_mult_inv_sum_masses"))
+        self.addBlock(NegatorBlock(block_name="neg_vperson"))
+        self.addBlock(NegatorBlock(block_name="neg_xperson"))
+        self.addBlock(ProductBlock(block_name="mult_neg_vperson"))
+        self.addBlock(ProductBlock(block_name="mult_neg_xperson"))
+        self.addBlock(AdderBlock(block_name="sum_mults_person"))
+        self.addBlock(AdderBlock(block_name="sum_sum_mults_person"))
+        self.addBlock(ProductBlock(block_name="mult_inv_mperson"))
+        
+        self.addConnection("m_train", "sum_masses")
+        self.addConnection("m_person", "sum_masses")
+        self.addConnection("sum_masses", "inv_sum_masses")
+        self.addConnection("inv_sum_masses", "mult_inv_sum_masses")
+        self.addConnection("InTraction", "mult_inv_sum_masses")
+        self.addConnection("mult_inv_sum_masses", "mult_mult_inv_sum_masses")
+        
+        self.addConnection("m_person", "mult_mult_inv_sum_masses")
+        
+        self.addConnection("m_person", "inv_mperson")
+        self.addConnection("inv_mperson", "mult_inv_mperson")
+        
+        self.addConnection("mult_mult_inv_sum_masses", "neg_mult_mult_inv_sum_masses")
+        self.addConnection("neg_mult_mult_inv_sum_masses", "sum_sum_mults_person")
+        
+        self.addConnection("InVPerson", "neg_vperson")
+        self.addConnection("neg_vperson", "mult_neg_vperson")
+        self.addConnection("c", "mult_neg_vperson")
+        
+        self.addConnection("InXPerson", "neg_xperson")
+        self.addConnection("neg_xperson", "mult_neg_xperson")
+        self.addConnection("k", "mult_neg_xperson")
+        
+        self.addConnection("mult_neg_vperson", "sum_mults_person")
+        self.addConnection("mult_neg_xperson", "sum_mults_person")
+        
+        self.addConnection("sum_mults_person", "sum_sum_mults_person")
+        self.addConnection("sum_sum_mults_person", "mult_inv_mperson")
+        self.addConnection("mult_inv_mperson", "OutAPerson")
+        
+        
+        
+class AccelerationTrain(CBD):
+    def __init__(self, block_name):
+        CBD.__init__(self, block_name, ["InTraction"],["OutATrain"])
+        self.addBlock(ConstantBlock(block_name="m_train", value=MASS_TRAIN))
+        self.addBlock(ConstantBlock(block_name="m_person", value=MASS_PERSON))
+        self.addBlock(AdderBlock(block_name="sum"))
+        self.addBlock(InverterBlock(block_name="inv"))
+        self.addBlock(ProductBlock(block_name="mult"))
+        
+        self.addConnection("InTraction", "mult")
+        self.addConnection("m_train", "sum")
+        self.addConnection("m_person", "sum")
+        self.addConnection("sum", "inv")
+        self.addConnection("inv", "mult")
+        self.addConnection("mult", "OutATrain")
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/cbdsimulator/CBD_Controller.py

@@ -0,0 +1,262 @@
+"""
+This is CBD simulator controller exposing the most relevant methods of 
+a CBD simulator (See CBDMultipleOutput.Source.CBD.run) to allow for control from a SCCD.
+
+date: Oct 2015
+author (responsible): Claudio Gomes
+"""
+
+import math
+
+from CBDMultipleOutput.Source.CBD import *
+
+class CBDController:
+    """The CBD contoller acts as a facade to the simulator methods that are in the CBD objects.
+    The original design decision to keep the methods in the CBD Domain classes 
+    (as opposed to, for instance, keep them in a visitor/interpreter was not the decision of the current author.)"""
+    
+    def __init__(self, cbdModel, delta_t):
+        self.model = cbdModel
+        self.model.setDeltaT(delta_t)
+        self.delta = delta_t
+        
+    def initSimulation(self):
+        self.model.resetSignals();
+        self.model.setClock(Clock(self.delta))
+    
+    def createDepGraph(self, iteratonStep):
+        return self.__createDepGraph(iteratonStep)
+    
+    def createStrongComponents(self, depGraph, iteratonStep):
+        return depGraph.getStrongComponents(iteratonStep)
+    
+    def componentIsCycle(self, component, depGraph):
+        return self.__hasCycle(component, depGraph)
+    
+    
+    def computeNextBlock(self, comp, iteratonStep):
+        block = comp[0]   # the strongly connected component has a single element
+        block.compute(iteratonStep)
+    
+    def computeNextAlgebraicLoop(self, comp, iteratonStep):
+        currentComponent = comp
+        # Detected a strongly connected component
+        if not self.__isLinear(currentComponent):
+            raise NotImplementedError("Cannot solve non-linear algebraic loop")
+        solverInput = self.__constructLinearInput(currentComponent, iteratonStep)
+        self.__gaussjLinearSolver(solverInput)
+        solutionVector = solverInput[1]
+        for block in currentComponent:
+            blockIndex = currentComponent.index(block)
+            block.appendToSignal(solutionVector[blockIndex])
+    
+    def advanceTimeStep(self):
+        self.model.getClock().step()
+    
+    def getCurrentSimulationTime(self):
+        return self.model.getClock().getTime()
+    
+    def __isLinear(self, strongComponent):
+        """
+        Determines if an algebraic loop describes a linear equation or not
+        As input you get the detected loop in a list.
+        If the loop is linear return True
+        Else: call exit(1) to exit the simulation with exit code 1
+        
+        The strong component parameter is a list of blocks that comprise the strong component.
+        For a block to comprise the strong component, at least one of its dependencies must be in the strong component as well.
+        A non-linear equation is generated when the following conditions occur:
+         (1) there is a multiplication operation being performed between two unknowns.
+         (2) there is an invertion operatioon being performed in an unknown.
+         (3) some non linear block belongs to the strong component
+        
+        The condition (1) can be operationalized by finding a product block that has two dependencies belonging to the strong component.
+        This will immediatly tell us that it is a product between two unknowns.
+        The condition (2) can be operationalized simply by finding an inverter block in the strong component. 
+        Because the inverter block only has one input, if it is in the strong component, it means that its only dependency is in the strong component.
+        
+        """
+        for block in strongComponent:
+            if not block.getBlockType() == "AdderBlock" and not block.getBlockType() == "NegatorBlock":
+                # condition (1)
+                if block.getBlockType() == "ProductBlock":
+                    dependenciesUnknown = [x for x in block.getDependencies(0) if x in strongComponent ]
+                    if (len(dependenciesUnknown) == 2):
+                        return False
+                
+                # conditions (2) and (3)
+                if block.getBlockType() in ["InverterBlock", "LessThanBlock", "ModuloBlock", "RootBlock", "EqualsBlock", "NotBlock", "OrBlock", "AndBlock", "SequenceBlock"]:
+                    return False
+        
+        return True
+    
+    def __hasCycle(self, component, depGraph):
+        """
+        Determine whether a component is cyclic
+        """
+        assert len(component)>=1, "A component should have at least one element"
+        if len(component)>1:
+            return True
+        else: # a strong component of size one may still have a cycle: a self-loop
+            if depGraph.hasDependency(component[0], component[0]):
+                return True
+            else:
+                return False
+
+    def __constructLinearInput(self, strongComponent, curIteration):
+        """
+        Constructs input for a solver of systems of linear equations
+        Input consists of two matrices:
+        M1: coefficient matrix, where each row represents an equation of the system
+        M2: result matrix, where each element is the result for the corresponding equation in M1
+        """
+        size = len(strongComponent)
+        row = []
+        M1 = []
+        M2 = []
+
+        # Initialize matrices with zeros
+        i = 0
+        while (i < size):
+            j = 0
+            row = []
+            while (j < size):
+                row.append(0)
+                j += 1
+            M1.append(row)
+            M2.append(0)
+            i += 1
+
+        # block -> index of block
+        indexdict = dict()
+
+        for (i,block) in enumerate(strongComponent):
+            indexdict[block] = i
+
+        resolveBlock = lambda possibleDep, output_port: possibleDep if not isinstance(possibleDep, CBD) else possibleDep.getBlockByName(output_port)
+
+        def getBlockDependencies2(block):
+            return [ resolveBlock(b,output_port) for (b, output_port) in [block.getBlockConnectedToInput("IN1"),  block.getBlockConnectedToInput("IN2")]]
+
+        for (i, block) in enumerate(strongComponent):
+            if block.getBlockType() == "AdderBlock":
+                for external in [ x for x in getBlockDependencies2(block) if x not in strongComponent ]:
+                    M2[i] -= external.getSignal()[curIteration].value
+                M1[i][i] = -1
+
+                for compInStrong in [ x for x in getBlockDependencies2(block) if x in strongComponent ]:
+                    M1[i][indexdict[compInStrong]] = 1
+            elif block.getBlockType() == "ProductBlock":
+                #M2 can stay 0
+                M1[i][i] = -1
+                M1[i][indexdict[[ x for x in getBlockDependencies2(block)  if x in strongComponent ][0]]] = reduce(lambda x,y: x*y, [ x.getSignal()[curIteration].value for x in getBlockDependencies2(block) if x not in strongComponent ])
+            elif block.getBlockType() == "NegatorBlock":
+                #M2 can stay 0
+                M1[i][i] = -1
+                possibleDep, output_port = block.getBlockConnectedToInput("IN1")
+                M1[i][indexdict[resolveBlock(possibleDep, output_port)]] = - 1
+            elif block.getBlockType() == "InputPortBlock":
+                #M2 can stay 0
+                M1[i][i] = 1
+                possibleDep, output_port = block.parent.getBlockConnectedToInput(block.getBlockName())
+                M1[i][indexdict[resolveBlock(possibleDep, output_port)]] = - 1
+            elif block.getBlockType() == "OutputPortBlock" or block.getBlockType() == "WireBlock":
+                #M2 can stay 0
+                M1[i][i] = 1
+                M1[i][indexdict[block.getDependencies(0)[0]]] = - 1
+            elif block.getBlockType() == "DelayBlock":
+                # If a delay is in a strong component, this is the first iteration
+                assert curIteration == 0
+                # And so the dependency is the IC
+                # M2 can stay 0 because we have an equation of the type -x = -ic <=> -x + ic = 0
+                M1[i][i] = -1
+                possibleDep, output_port = block.getBlockConnectedToInput("IC")
+                dependency = resolveBlock(possibleDep, output_port)
+                assert dependency in strongComponent
+                M1[i][indexdict[dependency]] = 1
+            else:
+                self.__logger.fatal("Unknown element, please implement")
+        return [M1, M2]
+
+    
+    def __gaussjLinearSolver(self, solverInput):
+        M1 = solverInput[0]
+        M2 = solverInput[1]
+        n = len(M1)
+        indxc = self.__ivector(n)
+        indxr = self.__ivector(n)
+        ipiv = self.__ivector(n)
+        icol = 0
+        irow = 0
+        for i in range(n):
+            big = 0.0
+            for j in range(n):
+                if (ipiv[j] != 1):
+                    for k in range(n):
+                        if (ipiv[k] == 0):
+                            if (math.fabs(M1[j][k]) >= big):
+                                big = math.fabs(M1[j][k])
+                                irow = j
+                                icol = k
+                        elif (ipiv[k] > 1):
+                            raise ValueError("GAUSSJ: Singular Matrix-1")
+            ipiv[icol] += 1
+            if (irow != icol):
+                for l in range(n):
+                    (M1[irow][l], M1[icol][l]) = self.__swap(M1[irow][l], M1[icol][l])
+                (M2[irow], M2[icol]) = self.__swap(M2[irow], M2[icol])
+            indxr[i] = irow
+            indxc[i] = icol
+            if (M1[icol][icol] == 0.0):
+                raise ValueError("GAUSSJ: Singular Matrix-2")
+            pivinv = 1.0/M1[icol][icol]
+            M1[icol][icol] = 1.0
+            for l in range(n):
+                M1[icol][l] *= pivinv
+            M2[icol] *= pivinv
+            for ll in range(n):
+                if (ll != icol):
+                    dum = M1[ll][icol]
+                    M1[ll][icol] = 0.0
+                    for l in range(n):
+                        M1[ll][l] -= M1[icol][l] * dum
+                    M2[ll] -= M2[icol] * dum
+        l = n
+        while (l > 0):
+            l -= 1
+            if (indxr[l] != indxc[l]):
+                for k in range(n):
+                    (M1[k][indxr[l]], M1[k][indxc[l]]) = self.__swap(M1[k][indxr[l]], M1[k][indxc[l]])
+
+    def __createDepGraph(self, curIteration):
+        """
+         Create a dependency graph of the CBD model.
+         Use the curIteration to differentiate between the first and other iterations
+         Watch out for dependencies with sub-models.
+        """
+        blocks = self.model.getBlocks()
+        depGraph = DepGraph()
+        for block in blocks:      
+            depGraph.addMember(block);
+        
+        def recSetInternalDependencies(blocks, curIteration):
+            for block in blocks:
+                for dep in block.getDependencies(curIteration):
+                    depGraph.setDependency(block, dep, curIteration)
+                if isinstance(block, CBD):
+                    recSetInternalDependencies(block.getBlocks(), curIteration)
+        
+        recSetInternalDependencies(blocks, curIteration);
+        
+        return depGraph
+    
+    def __ivector(self, n):
+        v = []
+        for i in range(n):
+            v.append(0)
+        return v
+
+    def __swap(self, a, b):
+        return (b, a)
+
+    

fsa_cbd_composition/cbdsimulator/Options.py

@@ -0,0 +1,56 @@
+AUTO_TIME_MODE = 0X01
+MANUAL_TIME_MODE = 0x02
+MANUAL_STEP_TIME_MODE = 0x03
+FAST_TIME_MODE = 0x04
+
+#a list containg the aboves modes so that the option class can do an 'in' check instead of == one by one
+#to check the legality of a received mode. 
+LEGAL_TIME_MODES = [AUTO_TIME_MODE, MANUAL_TIME_MODE, MANUAL_STEP_TIME_MODE, FAST_TIME_MODE]
+
+class Options:
+  """A class that contains options that should be given trough the interface)"""
+  def __init__(self,maxIter = 10, mode = AUTO_TIME_MODE, scaleFactor = 1, delta = 0.001):
+    """
+    a couple of options
+    @param maxIter the number or iterations of 1 simulation
+    @param mode the time mode
+    @param scaleFactor the scale factor by which to run an iteration default 1
+    """
+    self.__max_iter = maxIter
+    self.setTimeMode(mode)
+    self.setDeltaT(delta)
+    if scaleFactor >= 0:
+      self.__factor = scaleFactor 
+    else:
+      self.__factor  = 1
+        
+  def setMaxIterations(self, max):
+    self.__max_iter = max
+   
+  def getMaxIterations(self):
+    return self.__max_iter 
+  
+  def setDeltaT(self, delta):
+    self.__delta = delta
+   
+  def getDeltaT(self):
+    return self.__delta 
+  
+  
+  def setScaleFactor(self, factor):
+    if factor >= 0:
+      self.__factor = factor
+      #if value is illegal keep simply keep previous value
+
+  def getScaleFactor(self):
+    return self.__factor
+  
+  def setTimeMode(self, mode):
+    """Set the time mode. If it isn't a legal value set it to AUTO_TIME_MODE"""
+    if (mode in LEGAL_TIME_MODES): #since there is no enumeration in python this is a check to make sure a level has been added and not a random int
+      self.__mode = mode
+    else:
+      self.__mode = AUTO_TIME_MODE 
+
+  def getTimeMode(self):
+    return self.__mode

fsa_cbd_composition/cbdsimulator/cbdsim.py

@@ -0,0 +1,387 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe and Joeri Exelmans
+
+Date:   Fri Oct 07 12:07:43 2016
+
+Model author: Sadaf Mustafiz and Bruno Barroca and Claudio Gomes
+Model name:   CBDSimulator
+Model description:
+SCCD HUTN model of a CBD simulator
+"""
+
+from python_runtime.statecharts_core import *
+from python_runtime.libs.ui import *
+from python_runtime.libs.utils import *
+from CBD_Controller import CBDController
+import Options
+
+# package "CBDSimulator"
+
+class CBDSimulator(RuntimeClassBase):
+	def __init__(self, controller, options, model):
+		RuntimeClassBase.__init__(self, controller)
+		
+		self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+		self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+		self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+		self.semantics.priority = StatechartSemantics.SourceParent
+		self.semantics.concurrency = StatechartSemantics.Single
+		
+		# User defined attributes
+		self.delta = None
+		self.strongComponentList = None
+		self.currentCompIdx = None
+		self.iteration = None
+		self.depGraph = None
+		self.cbdController = None
+		self.clock = None
+		self.model = None
+		
+		# Call user defined constructor
+		CBDSimulator.user_defined_constructor(self, options, model)
+	
+	def user_defined_constructor(self, options, model):
+		self.options = options
+		self.delta = self.options.getDeltaT()
+		self.model = model
+	
+	def user_defined_destructor(self):
+		pass
+	
+	
+	# User defined method
+	def currentComponentIsCycle(self):
+		return self.cbdController.componentIsCycle(self.strongComponentList[self.currentCompIdx], self.depGraph)
+	
+	
+	# User defined method
+	def advanceTime(self):
+		self.iteration = self.iteration + 1
+		self.clock = self.clock + self.delta
+		self.cbdController.advanceTimeStep()
+	
+	
+	# User defined method
+	def hasNextStrongComponent(self):
+		return (self.currentCompIdx) < len(self.strongComponentList)
+	
+	
+	# User defined method
+	def maxIterationsReached(self):
+		return self.iteration >= self.options.getMaxIterations()
+	
+	
+	# User defined method
+	def computeBlock(self):
+		if self.currentComponentIsCycle():
+			self.cbdController.computeNextAlgebraicLoop(self.strongComponentList[self.currentCompIdx], self.iteration)
+		else:
+			self.cbdController.computeNextBlock(self.strongComponentList[self.currentCompIdx], self.iteration)
+	
+	def initializeStatechart(self):
+		self.current_state[self.Root] = []
+		self.current_state[self.Root_DoSimulation] = []
+		self.current_state[self.Root_CheckTermination] = []
+		
+		# Enter default state
+		self.enter_Root_Started()
+	
+	# Unique IDs for all statechart nodes
+	Root = 0
+	Root_DoSimulation = 1
+	Root_CheckTermination = 2
+	Root_Started = 3
+	Root_DoSimulation_MacroStepPrepared = 4
+	Root_DoSimulation_MicroStepPrepared = 5
+	Root_DoSimulation_MicroStepProcessed = 6
+	Root_CheckTermination_MacroStepProcessed = 7
+	Root_Initialized = 8
+	Root_End = 9
+	
+	# Statechart enter/exit action method(s)
+	
+	def enter_Root_DoSimulation(self):
+		self.current_state[self.Root].append(self.Root_DoSimulation)
+	
+	def exit_Root_DoSimulation(self):
+		if self.Root_DoSimulation_MacroStepPrepared in self.current_state[self.Root_DoSimulation]:
+			self.exit_Root_DoSimulation_MacroStepPrepared()
+		if self.Root_DoSimulation_MicroStepPrepared in self.current_state[self.Root_DoSimulation]:
+			self.exit_Root_DoSimulation_MicroStepPrepared()
+		if self.Root_DoSimulation_MicroStepProcessed in self.current_state[self.Root_DoSimulation]:
+			self.exit_Root_DoSimulation_MicroStepProcessed()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_CheckTermination(self):
+		self.current_state[self.Root].append(self.Root_CheckTermination)
+	
+	def exit_Root_CheckTermination(self):
+		if self.Root_CheckTermination_MacroStepProcessed in self.current_state[self.Root_CheckTermination]:
+			self.exit_Root_CheckTermination_MacroStepProcessed()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_Started(self):
+		self.current_state[self.Root].append(self.Root_Started)
+	
+	def exit_Root_Started(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_DoSimulation_MacroStepPrepared(self):
+		self.current_state[self.Root_DoSimulation].append(self.Root_DoSimulation_MacroStepPrepared)
+	
+	def exit_Root_DoSimulation_MacroStepPrepared(self):
+		self.current_state[self.Root_DoSimulation] = []
+	
+	def enter_Root_DoSimulation_MicroStepPrepared(self):
+		self.current_state[self.Root_DoSimulation].append(self.Root_DoSimulation_MicroStepPrepared)
+	
+	def exit_Root_DoSimulation_MicroStepPrepared(self):
+		self.current_state[self.Root_DoSimulation] = []
+	
+	def enter_Root_DoSimulation_MicroStepProcessed(self):
+		self.current_state[self.Root_DoSimulation].append(self.Root_DoSimulation_MicroStepProcessed)
+	
+	def exit_Root_DoSimulation_MicroStepProcessed(self):
+		self.current_state[self.Root_DoSimulation] = []
+	
+	def enter_Root_CheckTermination_MacroStepProcessed(self):
+		self.current_state[self.Root_CheckTermination].append(self.Root_CheckTermination_MacroStepProcessed)
+	
+	def exit_Root_CheckTermination_MacroStepProcessed(self):
+		self.current_state[self.Root_CheckTermination] = []
+	
+	def enter_Root_Initialized(self):
+		self.current_state[self.Root].append(self.Root_Initialized)
+	
+	def exit_Root_Initialized(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_End(self):
+		self.current_state[self.Root].append(self.Root_End)
+	
+	def exit_Root_End(self):
+		self.current_state[self.Root] = []
+	
+	# Statechart enter/exit default method(s)
+	
+	def enterDefault_Root_DoSimulation(self):
+		self.enter_Root_DoSimulation()
+		self.enter_Root_DoSimulation_MacroStepPrepared()
+	
+	def enterDefault_Root_CheckTermination(self):
+		self.enter_Root_CheckTermination()
+		self.enter_Root_CheckTermination_MacroStepProcessed()
+	
+	# Statechart transitions
+	
+	def generateCandidatesChildren_Root(self):
+		if self.current_state[self.Root][0] == self.Root_Started:
+			return self.generateCandidates_Root_Started()
+		elif self.current_state[self.Root][0] == self.Root_DoSimulation:
+			return self.generateCandidates_Root_DoSimulation()
+		elif self.current_state[self.Root][0] == self.Root_CheckTermination:
+			return self.generateCandidates_Root_CheckTermination()
+		elif self.current_state[self.Root][0] == self.Root_Initialized:
+			return self.generateCandidates_Root_Initialized()
+		elif self.current_state[self.Root][0] == self.Root_End:
+			return self.generateCandidates_Root_End()
+		return False
+	
+	def generateCandidates_Root(self):
+		if not self.combo_step.isArenaChanged(self.Root):
+			return self.generateCandidatesChildren_Root()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_Started(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Started_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Started(self):
+		if not self.combo_step.isArenaChanged(self.Root_Started):
+			return self.generateCandidatesCurrent_Root_Started()
+		else:
+			return True
+	
+	def transition_Root_Started_1(self, parameters):
+		self.exit_Root_Started()
+		print('Going to Initialized... ')
+		print('Performing initialization...')
+		self.iteration = 0
+		self.clock = 0
+		self.cbdController = CBDController(self.model, self.delta)
+		self.cbdController.initSimulation()
+		print('Performing initialization... DONE')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Initialized()
+	
+	def generateCandidatesChildren_Root_DoSimulation(self):
+		if self.current_state[self.Root_DoSimulation][0] == self.Root_DoSimulation_MacroStepPrepared:
+			return self.generateCandidates_Root_DoSimulation_MacroStepPrepared()
+		elif self.current_state[self.Root_DoSimulation][0] == self.Root_DoSimulation_MicroStepPrepared:
+			return self.generateCandidates_Root_DoSimulation_MicroStepPrepared()
+		elif self.current_state[self.Root_DoSimulation][0] == self.Root_DoSimulation_MicroStepProcessed:
+			return self.generateCandidates_Root_DoSimulation_MicroStepProcessed()
+		return False
+	
+	def generateCandidates_Root_DoSimulation(self):
+		if not self.combo_step.isArenaChanged(self.Root_DoSimulation):
+			return self.generateCandidatesChildren_Root_DoSimulation()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_DoSimulation_MacroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_DoSimulation_MacroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_DoSimulation_MacroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_DoSimulation_MacroStepPrepared):
+			return self.generateCandidatesCurrent_Root_DoSimulation_MacroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_DoSimulation_MacroStepPrepared_1(self, parameters):
+		self.exit_Root_DoSimulation_MacroStepPrepared()
+		print('Going to MicroStepProcessed... ')
+		self.combo_step.setArenaChanged(self.Root_DoSimulation)
+		self.enter_Root_DoSimulation_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_DoSimulation_MicroStepPrepared(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_DoSimulation_MicroStepPrepared_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_DoSimulation_MicroStepPrepared(self):
+		if not self.combo_step.isArenaChanged(self.Root_DoSimulation_MicroStepPrepared):
+			return self.generateCandidatesCurrent_Root_DoSimulation_MicroStepPrepared()
+		else:
+			return True
+	
+	def transition_Root_DoSimulation_MicroStepPrepared_1(self, parameters):
+		self.exit_Root_DoSimulation_MicroStepPrepared()
+		print('Going to MicroStepProcessed...')
+		self.computeBlock()
+		self.currentCompIdx = self.currentCompIdx + 1
+		self.combo_step.setArenaChanged(self.Root_DoSimulation)
+		self.enter_Root_DoSimulation_MicroStepProcessed()
+	
+	def generateCandidatesCurrent_Root_DoSimulation_MicroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if not self.hasNextStrongComponent():
+			self.small_step.addCandidate(self.transition_Root_DoSimulation_MicroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.hasNextStrongComponent():
+			self.small_step.addCandidate(self.transition_Root_DoSimulation_MicroStepProcessed_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_DoSimulation_MicroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_DoSimulation_MicroStepProcessed):
+			return self.generateCandidatesCurrent_Root_DoSimulation_MicroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_DoSimulation_MicroStepProcessed_1(self, parameters):
+		self.exit_Root_DoSimulation()
+		print('Going to CheckTermination and advancing time... ')
+		self.advanceTime()
+		print(self.clock)
+		print(self.iteration)
+		self.combo_step.setArenaChanged(self.Root)
+		self.enterDefault_Root_CheckTermination()
+	
+	def transition_Root_DoSimulation_MicroStepProcessed_2(self, parameters):
+		self.exit_Root_DoSimulation_MicroStepProcessed()
+		print('Going to MicroStepPrepared')
+		self.combo_step.setArenaChanged(self.Root_DoSimulation)
+		self.enter_Root_DoSimulation_MicroStepPrepared()
+	
+	def generateCandidatesChildren_Root_CheckTermination(self):
+		if self.current_state[self.Root_CheckTermination][0] == self.Root_CheckTermination_MacroStepProcessed:
+			return self.generateCandidates_Root_CheckTermination_MacroStepProcessed()
+		return False
+	
+	def generateCandidates_Root_CheckTermination(self):
+		if not self.combo_step.isArenaChanged(self.Root_CheckTermination):
+			return self.generateCandidatesChildren_Root_CheckTermination()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_CheckTermination_MacroStepProcessed(self):
+		enabled_events = self.getEnabledEvents()
+		if not self.maxIterationsReached():
+			self.small_step.addCandidate(self.transition_Root_CheckTermination_MacroStepProcessed_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.maxIterationsReached():
+			self.small_step.addCandidate(self.transition_Root_CheckTermination_MacroStepProcessed_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_CheckTermination_MacroStepProcessed(self):
+		if not self.combo_step.isArenaChanged(self.Root_CheckTermination_MacroStepProcessed):
+			return self.generateCandidatesCurrent_Root_CheckTermination_MacroStepProcessed()
+		else:
+			return True
+	
+	def transition_Root_CheckTermination_MacroStepProcessed_1(self, parameters):
+		self.exit_Root_CheckTermination()
+		print('Going to DoSimulation... ')
+		self.currentCompIdx = 0
+		self.depGraph = self.cbdController.createDepGraph(self.iteration)
+		self.strongComponentList = self.cbdController.createStrongComponents(self.depGraph, self.iteration)
+		self.combo_step.setArenaChanged(self.Root)
+		self.enterDefault_Root_DoSimulation()
+	
+	def transition_Root_CheckTermination_MacroStepProcessed_2(self, parameters):
+		self.exit_Root_CheckTermination()
+		print('Going to End... ')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_End()
+	
+	def generateCandidatesCurrent_Root_Initialized(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Initialized_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Initialized(self):
+		if not self.combo_step.isArenaChanged(self.Root_Initialized):
+			return self.generateCandidatesCurrent_Root_Initialized()
+		else:
+			return True
+	
+	def transition_Root_Initialized_1(self, parameters):
+		self.exit_Root_Initialized()
+		print('Going to CheckTermination... ')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enterDefault_Root_CheckTermination()
+	
+	def generateCandidates_Root_End(self):
+		return False
+	
+	# Generate transition candidates for current small step
+	def generateCandidates(self):
+		self.generateCandidates_Root()
+
+class ObjectManager(ObjectManagerBase):
+	def __init__(self, controller):
+		ObjectManagerBase.__init__(self, controller)
+	
+	def instantiate(self, class_name, construct_params):
+		if class_name == "CBDSimulator":
+			instance = CBDSimulator(self.controller, construct_params[0], construct_params[1])
+			instance.associations = {}
+		return instance
+
+class Controller(ThreadsControllerBase):
+	def __init__(self, options, model, keep_running = None):
+		if keep_running == None: keep_running = True
+		ThreadsControllerBase.__init__(self, ObjectManager(self), keep_running)
+		self.object_manager.createInstance("CBDSimulator", [options, model])

fsa_cbd_composition/cbdsimulator/cbdsim.sccd

@@ -0,0 +1,127 @@
+Diagram(name = 'CBDSimulator',
+        author = 'Sadaf Mustafiz and Claudio Gomes',
+        description = 'SCCD HUTN model of a CBD simulator'):
+    Top {
+        from CBD_Controller import CBDController
+        import Options
+    }
+
+    Class(name = 'CBDSimulator', default = True):
+        Attribute(name='iteration')
+        Attribute(name='strongComponentList')
+        Attribute(name='currentCompIdx')
+        Attribute(name='clock')
+        Attribute(name='delta')
+        Attribute(name='cbdController')
+        Attribute(name='model')
+		Attribute(name='depGraph')
+		
+        Constructor(options, model) {
+            self.options = options
+			self.delta = self.options->getDeltaT()
+			self.model = model
+        }
+		
+		Method currentComponentIsCycle() {
+            return self.cbdController->componentIsCycle(self.strongComponentList[self.currentCompIdx], self.depGraph)
+        }
+		
+		Method hasNextStrongComponent() {
+			return (self.currentCompIdx + 1) < len(self.strongComponentList)
+        }
+		
+        Method advanceTime() {
+			self.iteration = self.iteration + 1
+			self.clock = self.clock + self.delta
+        	self.cbdController->advanceTimeStep()
+        }
+        
+		Method maxIterationsReached() {
+			return self.iteration >= self.options->getMaxIterations()
+        }
+		
+        StateMachine:
+            initial = 'Initialize'
+			State('Initialize'):
+				Transition(target='../CheckTerminationCondition'):
+					Actions {
+						print('Transition to CheckTerminationCondition')
+					}
+				OnEnter {
+					print('Performing initialization...')
+					self.iteration = 0
+					self.clock = 0
+					self.cbdController = CBDController(self.model,self.delta)
+					self.cbdController->initSimulation()
+					print('Performing initialization... DONE')
+				}
+			State('CheckTerminationCondition'):
+				Transition(target='../CreateDependencyGraph'):
+					guard = {not self->maxIterationsReached()}
+					Actions {
+						print('Transition to CreateDependencyGraph')
+					}
+				Transition(target='../SimulationComplete'):
+					guard = {self->maxIterationsReached()}
+					Actions {
+						print('Transition to SimulationComplete')
+					}
+			State('CreateDependencyGraph'):
+				Transition(target='../IsolateStrongComponents'):
+					Actions {
+						print('Transition to IsolateStrongComponents')
+					}
+				OnEnter {
+					print('Performing dependency graph creation...')
+					self.depGraph = self.cbdController->createDepGraph(self.iteration)
+					print('Performing dependency graph creation... DONE')
+				}
+			State('IsolateStrongComponents'):
+				Transition(target='../ExecuteSimulationStep'):
+					Actions {
+						print('Transition to ExecuteSimulationStep')
+						self.currentCompIdx = -1
+					}
+				OnEnter {
+					print('Performing strong components isolation...')
+					self.strongComponentList = self.cbdController->createStrongComponents(self.depGraph, self.iteration)
+					print('Performing strong components isolation... DONE')
+				}
+				
+			State('ExecuteSimulationStep'):
+				initial = 'CheckNextComponent'
+				State('CheckNextComponent'):
+					Transition(target='../CheckCycle'):
+						guard = {self->hasNextStrongComponent()}
+						Actions {
+							print('Transition to CheckCycle')
+							self.currentCompIdx = self.currentCompIdx + 1
+						}
+					Transition(target='../../CheckTerminationCondition'):
+						guard = {not self->hasNextStrongComponent()}
+						Actions {
+							print('Transition to CheckTerminationCondition')
+							self->advanceTime()
+						}
+					OnEnter {
+						print('Performing CheckNextComponent...')
+						print('Performing CheckNextComponent... DONE')
+					}
+				State('CheckCycle'):
+					Transition(target='../CheckNextComponent'):
+						guard = {self->currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbdController->computeNextAlgebraicLoop(self.strongComponentList[self.currentCompIdx], self.iteration)
+						}
+					Transition(target='../CheckNextComponent'):
+						guard = {not self->currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbdController->computeNextBlock(self.strongComponentList[self.currentCompIdx], self.iteration)
+						}
+					OnEnter {
+						print('Performing CheckCycle...')
+						print('Performing CheckCycle... DONE')
+					}
+			State('SimulationComplete')

fsa_cbd_composition/cbdsimulator/cbdsim_hierarchical.sccd

@@ -0,0 +1,114 @@
+Diagram(name = 'CBDSimulator',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'SCCD HUTN model of a CBD simulator'):
+    Top {
+        from CBD_Controller import CBDController
+        import Options
+    }
+
+    Class(name = 'CBDSimulator', default = True):
+        Attribute(name='iteration')
+        Attribute(name='strongComponentList')
+        Attribute(name='currentCompIdx')
+        Attribute(name='clock')
+        Attribute(name='delta')
+        Attribute(name='cbdController')
+        Attribute(name='model')
+		Attribute(name='depGraph')
+		
+        Constructor(options, model) {
+            self.options = options
+			self.delta = self.options->getDeltaT()
+			self.model = model
+        }
+		
+		Method currentComponentIsCycle() {
+            return self.cbdController->componentIsCycle(self.strongComponentList[self.currentCompIdx], self.depGraph)
+        }
+		
+		Method hasNextStrongComponent() {
+			return (self.currentCompIdx) < len(self.strongComponentList)
+        }
+		
+		Method computeBlock(){
+			if self->currentComponentIsCycle():
+				self.cbdController->computeNextAlgebraicLoop(self.strongComponentList[self.currentCompIdx], self.iteration)
+			else:
+				self.cbdController->computeNextBlock(self.strongComponentList[self.currentCompIdx], self.iteration)
+			end
+		}
+		
+        Method advanceTime() {
+			self.iteration = self.iteration + 1
+			self.clock = self.clock + self.delta
+        	self.cbdController->advanceTimeStep()
+        }
+        
+		Method maxIterationsReached() {
+			return self.iteration >= self.options->getMaxIterations()
+        }
+		
+        StateMachine:
+			initial = 'Started'
+			final = 'End'
+			State('Started'):
+				Transition(target='../Initialized'):
+					Actions {
+						print('Going to Initialized... ')
+						print('Performing initialization...')
+						self.iteration = 0
+						self.clock = 0
+						self.cbdController = CBDController(self.model,self.delta)
+						self.cbdController->initSimulation()
+						print('Performing initialization... DONE')
+					}
+			State('Initialized'):
+				Transition(target='../CheckTermination'):
+					Actions {
+						print('Going to CheckTermination... ')
+					}
+			State('CheckTermination'):
+				initial = 'MacroStepProcessed'
+				State('MacroStepProcessed'):
+					Transition(target='../../DoSimulation'):
+						guard = { not self->maxIterationsReached() }
+						Actions {
+							print('Going to DoSimulation... ')
+							self.currentCompIdx = 0
+							self.depGraph = self.cbdController->createDepGraph(self.iteration)
+							self.strongComponentList = self.cbdController->createStrongComponents(self.depGraph, self.iteration)
+						}
+					Transition(target='../../End'):
+						guard = { self->maxIterationsReached() }
+						Actions {
+							print('Going to End... ')
+						}
+			State('DoSimulation'):
+				initial = 'MacroStepPrepared'
+				State('MacroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('Going to MicroStepProcessed... ')
+						}
+				State('MicroStepProcessed'):
+					Transition(target='../../CheckTermination'):
+						guard = { not self->hasNextStrongComponent() }
+						Actions {
+							print('Going to CheckTermination and advancing time... ')
+							self->advanceTime()
+							print(self.clock)
+							print(self.iteration)
+						}
+					Transition(target='../MicroStepPrepared'):
+						guard = { self->hasNextStrongComponent() }
+						Actions {
+							print('Going to MicroStepPrepared')
+						}
+				State('MicroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('Going to MicroStepProcessed...')
+							self->computeBlock()
+							self.currentCompIdx = self.currentCompIdx + 1
+						}
+			State('End')

fsa_cbd_composition/cbdsimulator/cbdsim_normal_form.sccd

@@ -0,0 +1,110 @@
+Diagram(name = 'CBDSimulator',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'SCCD HUTN model of a CBD simulator'):
+    Top {
+        from CBD_Controller import CBDController
+        import Options
+    }
+
+    Class(name = 'CBDSimulator', default = True):
+        Attribute(name='iteration')
+        Attribute(name='strongComponentList')
+        Attribute(name='currentCompIdx')
+        Attribute(name='clock')
+        Attribute(name='delta')
+        Attribute(name='cbdController')
+        Attribute(name='model')
+		Attribute(name='depGraph')
+		
+        Constructor(options, model) {
+            self.options = options
+			self.delta = self.options->getDeltaT()
+			self.model = model
+        }
+		
+		Method currentComponentIsCycle() {
+            return self.cbdController->componentIsCycle(self.strongComponentList[self.currentCompIdx], self.depGraph)
+        }
+		
+		Method hasNextStrongComponent() {
+			return (self.currentCompIdx) < len(self.strongComponentList)
+        }
+		
+		Method computeBlock(){
+			if self->currentComponentIsCycle():
+				self.cbdController->computeNextAlgebraicLoop(self.strongComponentList[self.currentCompIdx], self.iteration)
+			else:
+				self.cbdController->computeNextBlock(self.strongComponentList[self.currentCompIdx], self.iteration)
+			end
+		}
+		
+        Method advanceTime() {
+			self.iteration = self.iteration + 1
+			self.clock = self.clock + self.delta
+        	self.cbdController->advanceTimeStep()
+        }
+        
+		Method maxIterationsReached() {
+			return self.iteration >= self.options->getMaxIterations()
+        }
+		
+        StateMachine:
+			initial = 'Started'
+			final = 'End'
+			State('Started'):
+				Transition(target='../Initialized'):
+					Actions {
+						print('Going to Initialized... ')
+						print('Performing initialization...')
+						self.iteration = 0
+						self.clock = 0
+						self.cbdController = CBDController(self.model,self.delta)
+						self.cbdController->initSimulation()
+						print('Performing initialization... DONE')
+					}
+			State('Initialized'):
+				Transition(target='../MacroStepProcessed'):
+					Actions {
+						print('Going to MacroStepProcessed... ')
+					}
+			State('MacroStepProcessed'):
+				Transition(target='../MacroStepPrepared'):
+					guard = { not self->maxIterationsReached() }
+					Actions {
+						print('Going to MacroStepPrepared... ')
+						self.currentCompIdx = 0
+						self.depGraph = self.cbdController->createDepGraph(self.iteration)
+						self.strongComponentList = self.cbdController->createStrongComponents(self.depGraph, self.iteration)
+					}
+				Transition(target='../End'):
+					guard = { self->maxIterationsReached() }
+					Actions {
+						print('Going to End... ')
+					}
+			State('MacroStepPrepared'):
+				Transition(target='../MicroStepProcessed'):
+					Actions {
+						print('Going to MicroStepProcessed... ')
+					}
+			State('MicroStepProcessed'):
+				Transition(target='../MacroStepProcessed'):
+					guard = { not self->hasNextStrongComponent() }
+					Actions {
+						print('Going to MacroStepProcessed and advancing time... ')
+						self->advanceTime()
+						print(self.clock)
+						print(self.iteration)
+					}
+				Transition(target='../MicroStepPrepared'):
+					guard = { self->hasNextStrongComponent() }
+					Actions {
+						print('Going to MicroStepPrepared')
+					}
+			State('MicroStepPrepared'):
+				Transition(target='../MicroStepProcessed'):
+					Actions {
+						print('Going to MicroStepProcessed...')
+						self->computeBlock()
+						self.currentCompIdx = self.currentCompIdx + 1
+					}
+			State('End')

fsa_cbd_composition/cbdsimulator/runCBD.bat

@@ -0,0 +1,6 @@
+@ECHO OFF
+setlocal
+set PYTHONPATH=C:\Users\clagms\Source Control\SVN_SCCD
+python run_cbd_sim.py
+endlocal
+pause

fsa_cbd_composition/cbdsimulator/run_cbd_sim.py

@@ -0,0 +1,32 @@
+"""
+author: Claudio Gomes
+email: cla.gms[at]gmail.com
+"""
+from bokeh.plotting import figure, output_file, show
+from cbdsim import Controller
+from Options import Options
+from CBDMultipleOutput.models.EvenNumbersCBD import EvenNumberGen
+from CBDMultipleOutput.models.HarmonicOscilator import CircleCBDDerivative
+from CBDMultipleOutput.Source.CBD import CBD
+
+options = Options(delta = 0.01)
+options.setMaxIterations(1000);
+#cbdModel = EvenNumberGen("EvenNumbersGenerator")
+cbdModel = CircleCBDDerivative("CircleCBDDerivative",options.getDeltaT())
+# Use keep_running false for as fast as possible simulation.
+cbdSimController = Controller(options, cbdModel, keep_running=False)
+cbdSimController.start()
+cbdSimController.join()
+
+times = []
+values = []
+for timeValuePair in cbdModel.getSignal("neg"):
+    times.append(timeValuePair.time)
+    values.append(timeValuePair.value)
+
+output_file("./plot.html", title="Plot")
+p = figure(title="Something vs Otherthing", x_axis_label="Time", y_axis_label="Values")
+p.line(times, values, legend="Something", line_width=1, line_color="red")
+show(p)
+
+print "DONE"

fsa_cbd_composition/fsa_cbd_simulator/.project

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>fsa_cbd_simulator</name>
+	<comment></comment>
+	<projects>
+		<project>cbdsimulator</project>
+		<project>fsasimulator</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

fsa_cbd_composition/fsa_cbd_simulator/.pydevproject

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+<path>/${PROJECT_DIR_NAME}</path>
+</pydev_pathproperty>
+</pydev_project>

fsa_cbd_composition/fsa_cbd_simulator/composed_hybrid_fsa_simulator.sccd

@@ -0,0 +1,347 @@
+Diagram(name = 'Weaved_CBD_FSA_Simulator_Manual',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Manually woven CBD and FSA simulators with the FSA being the dominant.'):
+    Top {
+		import copy
+        from CBD_Controller import CBDController
+		import Options
+		from fsa_cbd_weaved_classes import CBDState
+		from weaved_cbd_fsa_lib import FSACBDLib
+    }
+
+    Class(name = 'Woven_CBD_FSA_Simulator', default = True):
+        Attribute(name = 'fsa_timestep')
+		Attribute(name = 'fsa_elapsed')
+		Attribute(name = 'fsa_currentState')
+		Attribute(name = 'fsa_logicalTime')
+		Attribute(name = 'fsa_currentEvent')
+		Attribute(name = 'fsa_selectedTransition')
+		Attribute(name = 'fsa_eventList')
+		
+		Attribute(name='cbd_iteration')
+        Attribute(name='cbd_strongComponentList')
+        Attribute(name='cbd_currentCompIdx')
+        Attribute(name='cbd_clock')
+        Attribute(name='cbd_options')
+        Attribute(name='cbd_delta')
+        Attribute(name='cbd_cbdController')
+		Attribute(name='cbd_depGraph')
+		
+		Attribute(name='weaved_delta')
+        Attribute(name='weaved_processing_cbd')
+        Attribute(name='weaved_ended_cbd')
+		Attribute(name='weaved_model')
+        Attribute(name='weaved_step_executed')
+        Attribute(name='weaved_global_state')
+        Attribute(name='weaved_previous_global_state')
+        Attribute(name='weaved_triggered_when_transition')
+        Attribute(name='weaved_lib')
+        
+		
+		Method fsa_getInputEventAt(time) {
+			return self.fsa_eventList->getInputAt(time)
+		}
+		
+		Method cbd_maxIterationsReached() {
+			return self.cbd_iteration >= self.cbd_options->getMaxIterations()
+        }
+		
+		Method cbd_hasNextStrongComponent() {
+			return (self.cbd_currentCompIdx + 1) < len(self.cbd_strongComponentList)
+        }
+		
+		Method cbd_currentComponentIsCycle() {
+            return self.cbd_cbdController->componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+        }
+		
+		Method updateGlobalState() {
+			self.weaved_previous_global_state = copy->deepcopy(self.weaved_global_state)
+            self.weaved_lib->updateGlobalState(self.weaved_global_state, self.fsa_currentState.cbd, self.cbd_clock)
+        }
+		
+		Method updateCBDState() {
+            self.weaved_lib->updateCBDState(self.weaved_global_state, self.fsa_currentState.cbd)
+        }
+		
+		Method getTriggeredWhenTransition() {
+            return self.weaved_lib->getTriggeredWhenTransition(self.weaved_model, self.fsa_currentState, self.weaved_global_state, self.weaved_previous_global_state)
+        }
+		
+        Constructor(cbd_options, amodel, fsa_events) {
+            self.weaved_lib = FSACBDLib()
+			
+			self.cbd_options = cbd_options
+			self.cbd_delta = self.cbd_options->getDeltaT()
+			
+			self.weaved_model = amodel
+			self.fsa_eventList = fsa_events
+			self.fsa_timestep = 1.0
+        }
+		StateMachine:
+			initial = 'Start'
+			State('TFSA'):
+				State('FSA_Start'):
+					Transition(target='../FSA_Prepare'):
+					Actions {
+						self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+						self.fsa_logicalTime = 0.0
+						self.fsa_elapsed = 0
+						self.fsa_timestep = self.weaved_delta
+						self.fsa_currentState = self.weaved_model.initialState
+
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						self.weaved_global_state = dict()
+						self.weaved_previous_global_state = dict()
+					}
+				State('FSA_Prepare'):
+				State('FSA_Process'):
+				State('FSA_CheckTermination'):
+				State('FSA_End'):
+
+			State('CBD'):
+				State('Start'):
+				State('Prepare'):
+				State('Process'):
+				State('CheckTermination'):
+				State('End'):
+
+
+        StateMachine:
+            initial = 'FSA_Start'
+			final = 'FSA_End'
+			State('FSA_Start'):
+				Transition(target='../FSA_Prepare'):
+					Actions {
+						self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+						self.fsa_logicalTime = 0.0
+						self.fsa_elapsed = 0
+						self.fsa_timestep = self.weaved_delta
+						self.fsa_currentState = self.weaved_model.initialState
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						self.weaved_global_state = dict()
+						self.weaved_previous_global_state = dict()
+					}
+			State('FSA_Prepare'):
+				Transition(target='../FSA_Process'):
+					guard = { self.fsa_currentState.final == False and not isinstance(self.fsa_currentState, CBDState)}
+					Actions {
+						print('going to fsa process... ')
+					}
+				Transition(target='../ProcessChild'):
+					guard = { self.fsa_currentState.final == False and isinstance(self.fsa_currentState, CBDState)}
+					Actions {
+						print('going to cbd process... ')
+						self.weaved_step_executed = False
+					}
+				Transition(target='../FSA_End'):
+					guard = { self.fsa_currentState.final == True }
+					Actions {
+						print('going to end... ')
+					}
+				OnEnter {
+					print("Attempting to read event: ")
+					self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+					self.fsa_selectedTransition = self.weaved_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+					
+					print("Read event: " + str(self.fsa_currentEvent))
+					print("Selected transition: " + str(self.fsa_selectedTransition))
+				}
+			State('FSA_Process'):
+				Transition(target='../FSA_Pepare'):
+					guard = {self.fsa_selectedTransition != None}
+					Actions {
+						self.fsa_currentState = self.fsa_selectedTransition.target
+						self.fsa_elapsed = 0
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						
+						self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+						self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+						
+						print("changing to state: ")
+						print(self.fsa_currentState->getName())
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+				Transition(target='../FSA_Prepare'):
+					guard = {self.fsa_selectedTransition == None}
+					Actions {
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+			State('ProcessChild'):
+				Transition(target='../FSA_Prepare'):
+					guard = {self.fsa_selectedTransition != None and self.weaved_processing_cbd and (self.weaved_step_executed or self.weaved_ended_cbd)}
+					Actions {
+						self.fsa_currentState = self.fsa_selectedTransition.target
+						self.fsa_elapsed = 0
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						
+						self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+						self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							
+						print("changing to state: ")
+						print(self.fsa_currentState->getName())
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+				Transition(target='../FSA_Prepare'):
+					guard = {self.fsa_selectedTransition == None and self.weaved_processing_cbd and (self.weaved_step_executed or self.weaved_ended_cbd)}
+					Actions {
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						print("Going to FSA_Check")
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+						
+					}
+				Transition(target='../CBD_Initialize'):
+					guard = {not self.weaved_processing_cbd}
+					Actions {
+						self.cbd_delta = self.weaved_delta
+						
+						self->updateCBDState()
+					}
+				Transition(target='../CBD_CheckTerminationCondition'):
+					guard = {self.weaved_processing_cbd and not self.weaved_ended_cbd and not self.weaved_step_executed}
+					Actions {
+						self.cbd_clock = self.cbd_clock + self.cbd_delta
+						self.cbd_iteration = self.cbd_iteration + 1
+						self.cbd_cbdController->advanceTimeStep()
+						print("CBD clock: " + str(self.cbd_clock))
+						print("CBD iteration: " + str(self.cbd_iteration))	
+					}
+			State('CBD_Initialize'):
+				Transition(target='../CBD_CheckTerminationCondition'):
+					Actions {
+						print('Transition to CBD_CheckTerminationCondition')
+					}
+				OnEnter {
+					print('Performing initialization...')
+					self.cbd_iteration = 0
+					self.cbd_clock = 0.0
+					self.cbd_cbdController = CBDController(self.fsa_currentState.cbd,self.cbd_delta)
+					self.cbd_cbdController->initSimulation()
+					print("CBD clock: " + str(self.cbd_clock))
+					print("CBD iteration: " + str(self.cbd_iteration))
+				}
+			State('CBD_CheckTerminationCondition'):
+				Transition(target='../CBD_CreateDependencyGraph'):
+					guard = {not self->cbd_maxIterationsReached()}
+					Actions {
+						print('Transition to CBD_CreateDependencyGraph')
+					}
+				Transition(target='../CBD_SimulationComplete'):
+					guard = {self->cbd_maxIterationsReached()}
+					Actions {
+						print('Transition to CBD_SimulationComplete')
+					}
+			State('CBD_CreateDependencyGraph'):
+				Transition(target='../CBD_IsolateStrongComponents'):
+					Actions {
+						print('Transition to CBD_IsolateStrongComponents')
+					}
+				OnEnter {
+					self.cbd_depGraph = self.cbd_cbdController->createDepGraph(self.cbd_iteration)
+				}
+			State('CBD_IsolateStrongComponents'):
+				Transition(target='../CBD_ExecuteSimulationStep'):
+					Actions {
+						print('Transition to CBD_ExecuteSimulationStep')
+						self.cbd_currentCompIdx = -1
+					}
+				OnEnter {
+					print('Performing strong components isolation...')
+					self.cbd_strongComponentList = self.cbd_cbdController->createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+					print('Performing strong components isolation... DONE')
+				}
+			State('CBD_ExecuteSimulationStep'):
+				initial = 'CheckNextComponent'
+				State('CheckNextComponent'):
+					Transition(target='../CheckCycle'):
+						guard = {self->cbd_hasNextStrongComponent()}
+						Actions {
+							print('Transition to CheckCycle')
+							self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+						}
+					Transition(target='../../ProcessingCBD'):
+						guard = {not self->cbd_hasNextStrongComponent()}
+						Actions {
+							self->updateGlobalState()
+							self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							self.weaved_triggered_when_transition = self->getTriggeredWhenTransition()
+							if self.fsa_selectedTransition == None and self.weaved_processing_cbd:
+								self.fsa_selectedTransition = self.weaved_triggered_when_transition
+							end
+							self.weaved_step_executed = True
+							self.weaved_processing_cbd = True
+							
+							print('Transition to ProcessingCBD')
+						}
+					OnEnter {
+						print('Performing CheckNextComponent...')
+						print('Performing CheckNextComponent... DONE')
+					}
+				State('CheckCycle'):
+					Transition(target='../CheckNextComponent'):
+						guard = {self->cbd_currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbd_cbdController->computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					Transition(target='../CheckNextComponent'):
+						guard = {not self->cbd_currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbd_cbdController->computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					OnEnter {
+						print('Performing CheckCycle...')
+						print('Performing CheckCycle... DONE')
+					}
+			State('CBD_SimulationComplete'):
+				Transition(target='../ProcessChild'):
+					guard = {self->cbd_maxIterationsReached()}
+					Actions {
+						self.weaved_step_executed = True
+						self.weaved_ended_cbd = True
+						self.weaved_processing_cbd = True
+						print('Transition to ProcessingCBD')
+					}
+			State('FSA_End')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/fsa_cbd_simulator/events.csv

@@ -0,0 +1,130 @@
+fsatime,Event
+3.6299999999999666,when(x +-)
+7.009999999999895,when(x +-)
+9.729999999999837,when(x +-)
+11.91999999999979,when(x +-)
+12.999999999999767,kick
+16.87999999999984,when(x +-)
+20.160000000000352,when(x +-)
+22.800000000000765,when(x +-)
+23.000000000000796,kick
+28.870000000001713,when(x +-)
+33.640000000001876,when(x +-)
+37.00000000000121,kick
+38.99000000000081,when(x +-)
+41.240000000000364,when(x +-)
+43.050000000000004,when(x +-)
+44.509999999999714,when(x +-)
+45.69999999999948,when(x +-)
+46.669999999999284,when(x +-)
+47.45999999999913,when(x +-)
+48.109999999999,when(x +-)
+48.63999999999889,when(x +-)
+49.079999999998805,when(x +-)
+49.44999999999873,when(x +-)
+49.75999999999867,when(x +-)
+50.029999999998616,when(x +-)
+50.25999999999857,when(x +-)
+50.45999999999853,when(x +-)
+50.639999999998494,when(x +-)
+50.79999999999846,when(x +-)
+50.94999999999843,when(x +-)
+51.089999999998405,when(x +-)
+51.20999999999838,when(x +-)
+51.31999999999836,when(x +-)
+51.42999999999834,when(x +-)
+51.539999999998315,when(x +-)
+51.639999999998295,when(x +-)
+51.739999999998275,when(x +-)
+51.839999999998255,when(x +-)
+51.92999999999824,when(x +-)
+52.01999999999822,when(x +-)
+52.1099999999982,when(x +-)
+52.199999999998184,when(x +-)
+52.289999999998166,when(x +-)
+52.37999999999815,when(x +-)
+52.46999999999813,when(x +-)
+52.55999999999811,when(x +-)
+52.649999999998094,when(x +-)
+52.739999999998076,when(x +-)
+52.82999999999806,when(x +-)
+52.91999999999804,when(x +-)
+53.00999999999802,when(x +-)
+53.099999999998005,when(x +-)
+53.18999999999799,when(x +-)
+53.27999999999797,when(x +-)
+53.36999999999795,when(x +-)
+53.45999999999793,when(x +-)
+53.549999999997915,when(x +-)
+53.6399999999979,when(x +-)
+53.72999999999788,when(x +-)
+53.81999999999786,when(x +-)
+53.909999999997844,when(x +-)
+53.999999999997826,when(x +-)
+54.08999999999781,when(x +-)
+54.17999999999779,when(x +-)
+54.26999999999777,when(x +-)
+54.359999999997754,when(x +-)
+54.449999999997736,when(x +-)
+54.53999999999772,when(x +-)
+54.6299999999977,when(x +-)
+54.71999999999768,when(x +-)
+54.809999999997665,when(x +-)
+54.89999999999765,when(x +-)
+54.98999999999763,when(x +-)
+55.07999999999761,when(x +-)
+55.16999999999759,when(x +-)
+55.259999999997575,when(x +-)
+55.34999999999756,when(x +-)
+55.43999999999754,when(x +-)
+55.52999999999752,when(x +-)
+55.6199999999975,when(x +-)
+55.709999999997486,when(x +-)
+55.79999999999747,when(x +-)
+55.88999999999745,when(x +-)
+55.97999999999743,when(x +-)
+56.069999999997414,when(x +-)
+56.159999999997396,when(x +-)
+56.24999999999738,when(x +-)
+56.33999999999736,when(x +-)
+56.42999999999734,when(x +-)
+56.519999999997324,when(x +-)
+56.60999999999731,when(x +-)
+56.69999999999729,when(x +-)
+56.78999999999727,when(x +-)
+56.87999999999725,when(x +-)
+56.969999999997235,when(x +-)
+57.05999999999722,when(x +-)
+57.1499999999972,when(x +-)
+57.23999999999718,when(x +-)
+57.32999999999716,when(x +-)
+57.419999999997145,when(x +-)
+57.50999999999713,when(x +-)
+57.59999999999711,when(x +-)
+57.68999999999709,when(x +-)
+57.779999999997074,when(x +-)
+57.869999999997056,when(x +-)
+57.95999999999704,when(x +-)
+58.04999999999702,when(x +-)
+58.139999999997,when(x +-)
+58.229999999996984,when(x +-)
+58.319999999996966,when(x +-)
+58.40999999999695,when(x +-)
+58.49999999999693,when(x +-)
+58.58999999999691,when(x +-)
+58.679999999996895,when(x +-)
+58.76999999999688,when(x +-)
+58.85999999999686,when(x +-)
+58.94999999999684,when(x +-)
+59.03999999999682,when(x +-)
+59.129999999996805,when(x +-)
+59.21999999999679,when(x +-)
+59.30999999999677,when(x +-)
+59.39999999999675,when(x +-)
+59.48999999999673,when(x +-)
+59.579999999996716,when(x +-)
+59.6699999999967,when(x +-)
+59.75999999999668,when(x +-)
+59.84999999999666,when(x +-)
+59.939999999996644,when(x +-)
+59.99999999999663,enough

fsa_cbd_composition/fsa_cbd_simulator/fsa_cbd_weaved_classes.py

@@ -0,0 +1,20 @@
+from fsaclasses import State, Trigger
+from CBDMultipleOutput.Source.CBD import ConstantBlock
+
+
+class CBDState(State):
+    def __init__(self, name, cbdModel, final = False):
+        State.__init__(self, name, final)
+        self.cbd = cbdModel
+        
+    def getName(self):
+        return self.name
+
+class WhenCrossesZeroTrigger(Trigger):
+    def __init__(self, varname, up_direction = True):
+        self.varname = varname
+        self.up_direction = up_direction
+
+
+class InputConstantBlock(ConstantBlock):
+    pass

fsa_cbd_composition/fsa_cbd_simulator/models/bouncing_ball_model.pdf

@@ -0,0 +1,373 @@
+%PDF-1.4
+%âãÏÓ
+1 0 obj
+   << 
+      /Title ()
+      /Author ()
+      /Subject ()
+      /Keywords ()
+      /Creator (yExport 1.5)
+      /Producer (org.freehep.graphicsio.pdf.YPDFGraphics2D 1.5)
+      /CreationDate (D:20151030112720-04'00')
+      /ModDate (D:20151030112720-04'00')
+      /Trapped /False
+   >>
+endobj
+2 0 obj
+   << 
+      /Type /Catalog
+      /Pages 3 0 R
+      /ViewerPreferences 4 0 R
+      /OpenAction [5 0 R /Fit]
+   >>
+endobj
+4 0 obj
+   << 
+      /FitWindow true
+      /CenterWindow false
+   >>
+endobj
+5 0 obj
+   << 
+      /Parent 3 0 R
+      /Type /Page
+      /Contents 6 0 R
+   >>
+endobj
+6 0 obj
+   << 
+      /Length 7 0 R
+      /Filter [/ASCII85Decode /FlateDecode]
+   >>
+stream
+Gb"/L3KL#KP+:FEU20j9ikCec":1)DHH$d()+"YX26$g3ruVds,*V(J<U[Y9h7>r!i3gt1K&jruR7nsL
+A2:lRp$X1hr-XP9Yg9]UG^92Vm=0P29_dZ&a@PXlh6DD!rp;FupM[fpqo<XTA**<#s5!SPr9_8;QiI&7
+T!G_qs8Ch>&-#H*r`f:Or6rG]j+$k(=Oo9FT%j6<RqLH32IAo3T;qbV-2q6B.q'O>"rBSc6diINqJ#^K
+W9*^.10`!Bjn/t*pOF$;Y^Q&#cNh45qeuMl](jG]5IKLK]-+QO3m()&jgB]!Nmi6tod,pr>4P<9rO'n:
+)!>[1No%Lp^,"r5=-e!s0-)M![r7#]#d:AEfU&k^f,Qq\6Z:k`<0(%=m*!HG^9Q/(bC<Wr/p4Sc5Q30H
+csOL51l+<()K`7FlYN8UQcG`;P+RI^Q>GS=Xu_$8BsjTb@TYmS'bu!Y\A-VedcTj8Q*ju(4^$Q>,>nlP
+#JVp^?fOnP;L(DcD,gI<@^!lM$!=<IX$;j#pY$I&76+Vk:=bM=hcj)D?oM'<4gk1SH"at<'Pi2Dr#m(F
+$,>`WN/kOHmAW7Z]XBO)ANpCc:Hm:mkPFl_8?0`#1@ja5Os/0'Z$PiY%]G:KB3H%0A+a=,,euT0;rUp(
+lOUNS?k&qE)F'[o/UeJ>#SNQm%'Oq177lkm:6$+*3S%SAo27Sf%B?s`-=$'Y_[3QV`HlT^q*p`MBCbUs
+3f=q50YS!]*n#U^0i5:=#hWu^r[E=0YW`B"4U/:@=X!;,.NsP_qG3BK>@7boFC"u"7`JMlUZYAh%n,ue
+gc[j6(4@4hb2%ob.MF4N/E#rk-)A\nqoAh6Qcu_%rf_k.E[gT;Q$MJ3fY]oL&7D+Q(Po[KY%nKWUla7m
+(6HD-Q>pIP>[Mq5iAF>#C'94+J0#:E?O'tLDf3&t;5io57D+:'V%EVuJ2_n+nfbeQJLY:i.s$O8JFc?4
+-[c7[`S)[]!g`&-q$pN_hj:-DY]ht;Akj<4^c)mLZn!3Q.CeFb?rlVrIJ3BZ"*Oq0HgC3nK;PJmFj!.]
+]s/qHk-i0-*cNu_XA8[=i8Ud8O`QcmCaS_64p9YG[H8EDr)hF`%gG;d=TMrn.4s@/?;)+NC&?GL'[pNh
+.t3ID,>MUaMfI-49K5SU'p+BaCX<*:Y+AgFGsSf8aVh;i8P3<T'J6?u_[>^_UK4E(L-R2gs!'$U.q-C2
+WN"G,)k5PVr;-e&+tYt]ZpiZn*9&Z'3(P!P07_+t++ZFS5Pr%",%<CNT38:=h$!0(n,P2^#9=.Hh!u?B
+)T?\a]/XGU`YIB;6a<fuMs%8(bm3_XTMF*LJD#&dW4!q]"iT"1")G@J!X?Yr\[!_)7bNC58:^Q.,0])6
+rYu)E]/A7V@g(>"/>a]UbYYCN.F.4T1]Q"ILXA/\MMi(9Me^3a@ap<q+5$M931n][YAND$irgoQYs)1V
+)h1._,+sbM$:+W5Z"(2HOn=&_A##05Vi?Zc3E:F:@9?N.ng^opQc(-C'Z.`\-^WG#TGt4+NNLk<9.tS6
+.Fr@k@a"**nM\VORPX9Q'/<%MV,;tn9.:7IX$V^qd,6)cnjC2=V>f59C$#pUfK[&+l"5c:s4LD[s8#6M
+]YEe3>PEVN;#Sl+"L]WICO78pVr:bHULL8BM[%PtIsa$]FLBEdfbtq$ih(_lF_Z8am'an5e=Y`pb,W^L
+)S(DiYm6Bj_OSf8qN8rD0$l8Tpa%!DA,8%o/cX^@rh$%B6UUjoNm#cC^gCGQs$([V$d<sa*CJ3cZ*H=f
+g>61A^@^?7mX__M2lt!GJF(;B#&[PCelZ^@iS:Zul%Kd-Qa((HcGUTYP:O@VG'liq-M;qh,$B<IjkKOo
+`nWs%Ko7UL^PK;XIpm6kM%9JFAt$eeM6cP\-^J?=h=5T'l(@K@rs-"g+%SGdrPl`jNpDkFjL)BJC*.G&
+ngHl[\+C'[*\KR@-8h2T@7AY3JlKe,=+8pBqg]21`@tZBikE-O*])VUDF6<#NWJGUUi4n<>A37Y/%;3p
+EbO+k>F[a@h?\e)Q4CWti+Qg[TitXXV.D4>_nTGe,@\BfPpnPe?)=il\YBY87`F-'qGp*:m:)bX.Z_P(
+@I>cbC3RBbF'>UF0/[cUbSm=;f)K5^g;6]K]$fT]e^?08?dKrkVIca&&n1smiD%.X^2Hd:N7;Y9%uNmJ
+Vd\YORV5k_>'9)G8kP=B@4?s/ZD"ZNeP-pT2tgd^-ap>qBPqOZdlYFIe<M2l/A"@^omQ]`jj2Q%J?P/4
+_iuWanX=0sigDmdh#jC<DI5Ndo>-cNW4llYGa'Ah94IPH-$&!SX(V?YNUd])bO'rNMb-6,=$X^X>>g7Q
+eFti(BmF(e4&:[7[FBQCQN@?,KaqB=T/@+.3*mi6"pr#$(&1r?N!M^L+U5cfS95_s>XK,mCRqkC6"YM4
+7ao.<:"i8nMC)<;>[-C,=P9#uT2TPDar$'UE!t]j-u4X@)F9Q^K/G-td@9E*mT=;=/P0Q\jM6?oUQi6+
+L)3#)5ScM\)!EtfaeR/K$=l-Ua+2_+bpJ%Mp<Sanbcg,?b*23BW(gHTB)*+`]nFp[VDqZZGHEU)@PG0&
+cqNX7=%HT8XsGPugb-Z6l!3Lqg9R&D;*QTH!ceoX[&\YVieBk),lr4+KfJKql'jV\9`apb#_=?@or-te
+_^r6L$00&bmp^,(ACC[IH5TZ%VW@Ws$\Jq%!Eb[\'+!5;?BaDb./$)4,:'Oc@_/DF`Z2eWTBN,4omm7C
+5%##7Anp/DR^^FXnHrDJaoq-:L=c(eKuK*WDu2\DYhJk3%P*$g0#M#p#uUNN-R$1:!r"(.TKE.q4cUhH
+TL9L\r1Noq-ak)n!0.Gr%0lRR(`6W.%#SiS6tiR5@UDq+IGmKf,2?6!0pXh:PjDU_X2k+WJ_Qi`;]^n*
+EX]X0Z[*HXSQSV'hEp>rf\Si?k\/XP;*V_I]./PP]s>cUN-G,*jLha,iuu(b[D4>$;8_&Jjt'U>Q\lmS
+RX;P,W,(Y.`:=/GV"BVa<:ujQ>.g]]:APK'o`:KG@[o:m:(;nMVsm$41;ps54A;^(_*aA#O.F\0<:#]t
+!]#H:)BHM>"('Nf@LI5e3=o2V)n;$lGg1%JYoLp&L%CH7T(>j,qd?BZ3Pr8\+l0C,1O"CRNH/!Jm8^oH
+HZ"_bJj-,0)PFW?*,UR"A$p8&cBh2?J3l(;:8A<#gi-(MGO1]!#Z^3k!cdQY'Y086]N.$,CS2Zl0HdXs
+6!3ENQGf_E)U'Y7]e`HY<JQ9;;sPgVcu=407;.RR5kDef/qqR^lC4^aH#1>@'>@_7"mmq<@`XOCZV_T%
+kbJi,e7Ng0phX!YTo`kZ5YlCAjG)HLQOm;::THb10p=@A-e<8Q8#g&N-PkS>Kl6!QjO9#^k`Bj0a6-RW
+HVf>7^H2WYAG'O[QN\'`EB`AQPam0BU<[n2q+qPnDLlHSRr;JdXLIt:kp\T/1X5t-l/nJ#CHYqQE>[hc
+ZOgfZq.=[&38[E$Q8mb=g3b.3I'ZZ;Rr;]SP:jRP\;eBbeGV:<9Uq&Z^-V]6_%!09.6HDeolg*7F@jCG
+L/]YJ2hj6J38T$<\]au&QV+mcAoLHfc9RrOWaYK.n-g[&;Y#Z_]WWs%5tU,+%FU#Wpr9Q254Yl<nBJmT
+iUG*lQXl@j4*l?sgg,s8VI4al945Ya:2!H4lUU;_6<fn&boa4:#n>W.kl]d`Ju/KtO$meDZ/_40)&j\M
+;@rqZY%G+EEI?r>*GJ-O3L^e?l,<.['m["5#>j@"`^VK,/o<p<[Klj92MDIQ\5;7[R,c.i?"lCr*nDVg
+L!g26?e&R:1pEguZk]po63TEsC.h3[hUo9IA)A:oFWEC^3e+un-+RJ6j31Y2&OWjEq`(k6^<F-em>MuM
+FVO7[_7So#\Xd1S<Tfr6;9l]6<Rdau'?ej1IOWdYnl=D[q&2c7TZ)FRNnM(`NRV"*/K?'F#1god`8:#N
+NH,?[hJKA]f$%S/hb$)(fIXs%ET;uU4=k?GoTO,(^Eq4%RT[pLLP(>$ORq(=h`S07Za4`8c*n[.f"4Ru
+engj=3A743X`q`EBrDiJc,7=^P-2b`^%0p,35'qhK5pb/5VVXfBQDTa`d)V:B5eWeCbIXqnGURsDrE+\
+g6k&l'WX2G9Lj$5^)l#gdT9SH^-&ipe4@u/)3[2"3#!I&lOFhM4l]a%,aERo+MPSR=@#(0.u/UGVp'Wt
+j8CunbB_@70NXRZn;hL',[^=pj68ONN]m>Bm^?_D]<mpWH,B+3i:b=d:r[*orrb,@lB5R+'PIO'Z!ZgA
+/_.@(O`>=`$gAs$1?O-W["JDj%3CA_<a'/;-^Nn5b\;4)ju":L=9;t?P\3dN*EK@c&F:o!/[dN<lk7O`
+GKkuq#1R)J(*P9li"Jc4(SEYY!JO&YPVtkS69,3lLcF>.Gq-SaLb#`iWRCB2jI;k011.C?6#=8tAiR-6
+a_kZ!'6`@Z"<;.e'2p'^/^tG<d1,k+UV9u5U6I@"QA/GU"8Qtm'/`sE)dshWBao,t`\/")4ZX28-I`[Y
+!@LUGK$U/EH82-k=ZVZgd2+Y3=BX+V0;g4CGj14C`D&8AOo4I28f;tGg`"[D6`:.V8[YKmnX=Ik?lcM?
+-m[*=rJmG4Lcnm078BGoH2<giM+rKNW'?s"V*d'ds)@tq$+nVp>VB'/pS<$XLeBH\H4i^aY`U*:Xl^9i
+M^s5o7#+*nRrMA,3F,T>MPfn687,5A@Li]lYU]W^@r/hD9?J\3[jS9LPR+7=:o"U[:34Q;_Z3D3Q%;ig
+>^'"t%^U/p^]MARr+b=mg8Qu3V(J]/X^Q7MU/3+PPKjttOLC!P(>C^$\30gk<D$-&?+hoFY5'ED=-f_-
++cTIA1u6-;j:%F<]V%rW"4=sUQ*fb73E8XW9ONn#.h0W[VIIYF-IGL<V+[QR4GKuckZcl';F,^M?dMp7
+2>S*5H98C]l)a>=?gGgsX=qYU;q._i+T";BKOlgc)C>LSV2Z=NT*KffO0)S[)`*Hnde#C-c.JU?R[/Ts
+/$6cDCp>-FYO?ie_U[s@4ZV%7Z+-#e*B6j*bZu%j&0=Knl2>20>2[Q4@!0Ie.q=cP>Ior:T&CmmTs5j(
+J`u"04W;kmB"SK0KGnFD\ia=@C$&BRihsqe2t>[[1/,)b+*9.p)Rj9..0Rn95pInc2e0RaV):A$C?HIO
+`NjD.*P,/R\#!aM^cKNAkB$-%]4QE^a3b&gF'Scl6@u&>k5Jc%SlCKF?I,VR^GIcR]8m377:SIe;+brP
+rVejaeR8`-X+R?;*j:_cr8cHla8:2=o'6\n19U#g(U,RUJV*iQGmmJ)"Smbde>b-2HPbl.dAF1j%B`jY
+$80YXD=\.AZ8cAGR@%3:=+#eqH:Ui<U?L(_0?>+th#Um7q)(@%?1VRZAc@OW?WRUX]tO"f/r-OR*bJ<l
+pkp">G2)kQ$YFPJ;tFt>0#GkPa)fgW8A?L23R"93nL5L@W29_>S?\TQdnD5g5,?W1bY17YTjK3>N)<m'
+3?u/cEkJ6;V16L7apNH6BmB8]_jsEG.N@PPo-;!AAcI?Se!1"GDlt(OEL,k-D\?sXWe989k"M6BT.q-;
+_He&r<_?#,<bWj^6Va-0M;BX[Aj*D!RLj[`J@au$e>+BYWRi<%Bb';MBVT/i-,WIojCLCV%sXph:O#`j
+[@5<dW6VgYCL61AX%$leZug)UdDFUMCCZ7s>#/5b8PV5%="o$uZG;Vs)YKn$[`3P6N\a2<dV#;IPnm/0
+o&Nh@e0-hKQ"EI"D%o)a0pdujSudX,Gk\_EJ&]JqW/GB"]XkVXV(^1/dO0:+BBc&YGTGhaPD;Rf+(S##
+Of`7?W!YZLM2f5=JS@F.2*G]2Q"`0h&)^[(ahN:T>'B0qp<>7jc[E@"q`602.VF9r]%*ph/ua3REdGN.
+3i/1c.6Z34&Q^H[oX'3#2L66*l0^hGas5pcF%T4f/'c)'d][mjkn!%1(e+Ee>(#&cl[.DE4IB&n_HCcb
+o%0,?j*sL0qtUa#6N,:'D4[0cW6,s(W3#9C4oPlgE(W@eq%?^E=aRkn-H9D62Q^HbNJht.R[C'L1=HtV
+]+S3ATp6mk$1TGbWJ0e2]ePo]dSp#*P^[l>R9u#CI_J1a:bp9cWTh!n90pTN,sD2_r\O2a)BSQ=a.#$)
+UOMG%o_&4#oYZY_+5Ak=j/jESpo#8qhIX\srGZ8q%tTdjLt0\r&$[asog@Z4+(F>QoL#9U5HOD+%tTai
+\<6$2NqXBIO8>P[f+0N.;ls7gjEg4A%tTdja;/Xk&Eq[UdJBU[Otp6+giP@Nd.,YQkts[Hn^\5%Nd_7U
+l\@@SqB=55%keVZmB%I>7=+9T)t+hte.4Jr*^X.MrGZ7BT-![CNH]Z/qVfGk+)XdN&6(^e+jd>5![%@P
+,oupqkgg7t/1sN'IL(&f_oKLe2>+kjQZTuT[*RL_q$$NK6Jt<0$Ft^,H+^9bD2NOYHD-j"&jc#F;Ah^`
+LLQ+@5V"WT_hAO+ERp^CpmeAr-u#n0=;eoM5IZUL1I=sn^T<O=,q:J+\C,4VT3W?D]R%4(06*+1]m(Yi
+=omb348p+a!dqJa2qq&DL",C"`UK4r?_8#uf_+]5j804F+4na-46>3:l;o#H6eAa:/S+>E:(DN;rj+`e
+_JD.$G`5/g\Ot#[Zj0V`NXL\\FflgkdW<0sBqN'/Ah^/[H."/NWo71ak%[/ofROpM3aZgt*WaKF8`Tjg
+D2*[f:9V%C3o=fH=qZ`g%NFeZJ[?UjWJ.`d"!0<lJM,qi4+R/c7nDC6ms-H;-K7\LBMr:RT(fpHgUPnU
+0UrbX\O]F6/>U9W(Wn1ehFJHQ!.$2o4a`)bQA)VJdoB0*WGS>1+nF%-op?-[='DV?4E(qU0,sd*],OJB
+U7gs/]$*Y!'C!rq2`RFDND`hKFMZ2aYlfbrr,RlOYg%\AjY47Wa&e8^Po=feiY(;Tb6[9eRpS@AXH-";
+di<dpfeR-".:9MsZG`]O(Gae0Y#?dL;X?&kiURicPP#g>;Sf3p8b"2Db'9-X*rjQM$F]Q;V1R_P'g-$Q
+$Lr,cmk7?aeF6<bPl<'G*4lnmSa/dnUd>r[;PB%R.Y)8(.Y&_P<%-dm$:%*2Ch-FP@nHoR\YTAu]qkd'
+h,4823`:P%]qdt4[o=d9Q3q1c8qi7!.NnDH$HVI&"dX4$"k;O&"k<$4"e]'LTKPdpOH6hLfZ9l*`fpi.
+E_?SsHV9&JDQ/.)*N=SchGOBV3Dol04]2<&\>@'^-5DX=8-S'rUr"@kr%4o+RZ3@_h"AeR*eh,iE^Gl)
+FAUSKYU$cnnG'aZ$NGXa-AE]SW]RcSLLVluH%UA%`f5U?24FgM(rfQq6_6tmT\4m)SCpes2OoD9:6j9t
+`P3_-HFt?DEG%9tP[c=E3JQD)=Zm1gcE*l$h*U8rf\Si??d>uV;*T63]df%^:];R$#OL])Oo'/*G3Nd_
+UrNi+dhp0TEME2!,'`E(1l9AMa=9*qHe6,Fnl1dR?mBka*<h7$U_UoK&TZ<d]kPMcL0n`k9Vnjj8(QU#
+(c?om7&RO[IH*e8deD4N`Lq-;X4OTI=bS7u2ms+.8YQIO_TNj9kn'sb/8(_:dKLsK*_Z6IXDoJMTHM@6
+$>BkWmlHH<Op!OD%bG3FI-%jmbr1c=C`^6T_0e[Y=q@JSo=i&A?e?0,hf.jNIBgp+&m\NcGq<i7#c/]U
+%-GafrYq2*qA/!!G%@dXm8)cpaZ8AC(]$=rNJ<T/fSbBd%@nN;8uj7Y:aSe'[A'ER=Q"DSA8!>0``B/5
+n@@^1^<0lXj+-sN^P'9p;neMRk,ftrRb7c`Bt9Q:PX,\Z^P%]7f:I1;f8of%XmL;GCY_i_WD+RPKEi3&
+UU2bX\,=F3[7>.N7dhoZ<M",3UOFV9ds"_q?T1$8X)pmB(jRG#DOh#XXUN*^.BoTthLqL_Vp(6&.Hjg]
+M5?d"r_htPNo<[W`L$,EkcQRCYiKukc=&pqm_#d13"W.Gp^o#>I;r_%&FUTlcPJrsre.Hp3d_0=3>fc7
+jXB?*L&(h"bQ7Tdq9G\Hg>7JDn;NcA3JdG'fT@nYpUiEO=Q8>.?H"_1U]ZK9js<mcDQ.=UQm@'l#<F`_
+h#kHpS_2''ll_EhT.W\JH*^;m.5]%&Q+A<:$^G18M%bOg:t>o&kIjV<76jFeOFc0G+Pu]Vr?:>/oea$n
+BXEDa$mGLaD'.cl29bS:\S%l&9p22ccOApNYZ+Z*/2cnDN]N.m(77C]a%h]W9auDg?p5PN=D\>mV;9/O
+Pnl@S\sqIcU@I#K$%_UbBkF1+YrmqQ:?eFN4kC';`DV<Y.OP%<&4s$T5`1g7@FRlD(-Z(q;#bK<"G6G!
+k3m-RS!o6hA((_u;/Z\Ndf^X,0G;)>c)!Nq$09j&NQ,6KZ&"$!4WJs4#>,=W>.R2&iB8XqrJl?Bf-p;F
+I$?\c;<^)'j"j;ML\m%YV:1.(l\q=aH-^Fs-D#R=)dP82B"65GgM;Obj>,5iAiT\9jr2EecU:g6bu:Q<
+gO'B9hY.F;H#n&I;I/$add$Pe/'$^WlD4BncZ"nl/ods1cG$Y'DJ#72il%8(CRX4(HKc,kT^S@I*#de-
+iF)7tAiSG\bWWj(g9hR%H"nZJL#=keN/tS*`=%PD)D1ZZU!l)X28]kE$g\efoi2B1jLk<>nE*YOk+tj-
+4Y$S0?72Gu[^?U.rh^`iKl"I!2rhVr33gT5:P]jhTGh%Udg+e\=U?8UMK+s9Dkt'5_`jBJF"X(mY-\_J
+8Kd5s&3-X&"Y5FQjf8hhHj;"=?#fN>6r9P$15*#cX#sfeV?Z,ib):.do3gTArr4;#GPq=VrQi%CQoaE=
+&pTEeH%K8+FGf"S7Ml&%dgd(P?,94R8#e$gPH$&q9/Z,._O[:n8e/GZLa+J;:S.>T[h/j8$usJjf/1JA
+q%!0\;[guV@d0-5]kh-D5i6^0`]O-#RUTY*#'U8m)K.T1f!fG*#%%(TMbOk#=de25J5RG%Au<S[6YgXL
+2cg7mdKHCra3k(erfS)"/DiB=\7"(TZ"<+*VX(*0k<__oP`s'EEp'5+Fs,Et:>V[k,O]:,M^:ZaAmM3b
+>Y$>sj!h]3?MsL7(N&nR(r#d6p>Y%CGI#M9gQX#BfV3CqMl=_gJ;Y1AZnT/9V)n8]ms8foH6fC6[XT4i
+GmnDN@-/+qL"u!6qHEQ24FN_u'(h*/*5`GK8W(lN\Pu+?90uE>O;cc*(OG*I*V72RO%k0R-K[+_$L,XD
+aC5sa.2EsC*Dr/'>2jY">9BKqDB+'Y*Z4.KOoQE#ePs)"lOV+8P*9(6eQQ`1q/CTUkaHD0B"@0brPqXA
+k"A1]]8e_6qhVGIOP>K<'>j<QoZi.-cUXSrQ,B9JJC4B%QW,d0r`H+Xh&fa:<V8kkV:lJ$5dM%ZcKX_2
+UTUYn)e\BR=qZkAYd`035N=006.CUo+_&r-Gc/lfq(qa84T.(5_rD+8SrX@FA)a";F=np4`k6:4jK[Jo
+"JTp4,:T@'C!/Z>#B-CSfu#&t4q@8S^A0Y2E5$deqatMp4Dm9($TENY]^'%kTCJO/"7t)WiRj3=l+jPE
+`5b_#Fe<Z;O3c_Y(02'OP[\Qpg&+)g'4'WelL3XgDf?kj"%=7*K%k:j4.:2)fHoF2a2glB1idPEl!N_a
+r90;s;;2R3(#oGc1qfPOF>LjX<&AfA6>q5gNT3F30Jm\Eb8J:pShJ<:q^rW,ppt8%Lc:'R2N(Hm[Iu9<
+050N1FRaO@b5F9M-liZOoR1e<gUO/2n<MjNK?&Yebp\mB%k=$[2MRisQi/5^n!c)[C5!o)G[e;IDY"BI
+B_RNqlcJ,aN#Fk/QS"TDgQ_=KJDi+$,3%<SrWM]c,3&GkQaXhf.-JqsTUX?XG`_*))f[+rmG#XC<f:&l
+Ag6*LSZ4]p&`6P_+Qe;`ehcA%]NH#ei?[>&:M`q0"/U!.C-aNo,&f?nBZp/'!YJbgE0Si_)cOBo-_%BF
+M&(2n5OF"pUno'o4`A&IVU<'=h2TXt`l>AJ[5[*D+fN+R4OmG=DHX4L<2tpmpoML.TPuk)1n/(Jn)RfD
+oc:!e2(R(J#]LESE*RL58KV.Q$;,)92Tg)sGPSVg,<tDVZm_Jup*N"[Vs1jVmBa&:/sPFij2)S$1_.*C
+Sb[41X4Nhe15do#%,&7:HUImUf%mSh^>Muk:H)PS!`sdX$Z0t\#@EbfT]@kEj!Gg*ff2G#+n"$+#bj\c
+X@(B+_05#Ebs]Mn0';-V&!fW>:EEV7;C$!,.;Q*E5rQcHj>h$pk1!"r8Qp"RdK]DfM2,a-nn1m1kV/S*
+'r9"u[NKMQ7uEWXCQbjLmo[,XS3q\I9t<D+Z.C?r`Hi[QXa><NEM;S9;C1.SdW2J0M44>dUuR#fZjpf_
+JE6XFo.*^D'\mScIl6'Ilh-Stgtg?&9$NEC+2.$tHCj.]@r&,S#N4=iWc^LAD&o^[XfD>Q]sW"%BDJj'
+%pN8(s"D'nob/A8]CtWE*b.3gksUmO):'Cb^"G)QC!,UUBGFDC($TqrP@192Y]'im]U8k3&M9n9:\A\V
+YN8s9.gp3-^Du^;AZZm<AO.6X,[Do)ej\OWFL)4uAE&!51cr_`Z5..O]>&i(#TOGaBe@d#Q!BgK5aX<f
+%f-6fJDrDap>[tojrq2snPtV4%Bmpqd=0L=is-R3W=\Z#Xe0P>ZEs/p+)lTb^\':?KIor@-,2i.(8DPj
+GJ:oLgPs`U^#TGm:GZ("F#R6VjV@9\Vu)nr&*(\-R(cS(%rg]_cG<6NnP!<__$Q%?Y81,ZcfQg"lnjCY
+fCTBHf-"M&&^=pG*6r9@XaKlnd$h0gB>bf@fC:T=r3j^Q?If5j@>,mqI$ja[I4MSPE?f@KD!\:,k'$,0
+=)n8[1p^Yn7&-J;&%VI.?K\2kYU$3ZW#t-jMuIf=+YCsbG&14:ko-#>N=3h:6c[XhXiM(tSsnc?:ZdLZ
+P[d)::&s92R7'+<Tf8PK`HktqNr\2S[:Eh_L[;[(l!SA,772KtMk?"J7NKnqeod?@SaJrB2S$$?6;O)t
+F:).Bik-8i9g)+p[)j`HP/`X'RU\@g=DM&%PbiC&e'4Ul0PX7L0'UAA:"I2u<mN_Xp>%^M_'#l^2E=!X
+oG**Ajkr[PlrP_U*2olBp=2uXrl1J'*9h/lg6/tG8g8.(#@4h[ADA1nS`E>+Zn]PP5\iC[nh*EY2mq=/
+Y[a"3Xh1pZ8*hJ1nJPLP_+cg:2FcGc4Rj$=Ab0<7fH))\"P^3>*l6[.Dg$n[3U@?*O@HHa+0jX*q2B_)
+44X]*f#nuJD*"LNK%oo0%=W5Z-f6gOEJLDt,IkiVa^_r-=<lJ_js/OK)8VmCTMJ@*=f'7iV%g`%YFar)
+m2]]J'lR/;4Ys#\?h)5e][JfZ]B6/&DAJdX_e,f@79M.V+gE(j[%9K6Qr]rj^i>!7HfnF#/"^2jp:d0k
+cT"K,M;!=OLj/\f>H8:ebObAPphE*]]1]$rENnQG"oW)dEr8XHHp:ehA"Ndc4OJVrVH)Q^oD/c:XhrP:
+^g#"Wh4&XMK?"R<m.>m$=^Oc[IjpfZ(,uNd4L:BdM%]']%XpB^B,0%ijLo/E-][mPLbF>Ia)Ik,\mGuh
+4hRc<)bS4sGcD!Ak,SaoM`eSKaF#@lL-Lrl?cggqW7$9q8s\.uh!-9m4ACj4201=]q>g\Z*<%9Jr(+@l
+\"+6$;0qqC:5E]J\m/NE2pL.<bs\0/RofOF.,PekZC-7)r8'L(nnh$JVo\a3aArN(i<t^=o:K$sXZOC;
+SZP9S5g%XVWc$JVYGj%kNXpm!A,KE^cLf'@:>^'M-/tAp"[J.1?u]Fcr77'Dq9"\L%YonidG).XB[Lbn
+I:9juDKrtHGN\$Xjks?PYK6SIBXgG-@X3CB!?L'^/W(:]HdQ+.)>:aDeH9t^Q/,BNs6qn1S_l+^mcok2
+p/J`5\LID1@"7a*gdN*7c^T?\h#^8-4TN(sS/4]S.HVuY98E`T:o]!RBK2P8$tt$FraPs+DN=UX%fppF
+hM]@2nK.j4Fc^\ZDVEpKYlNG7@XJVi?d#&Fi&j)*^sYW5,-Ufg<6Fq'e8t24FSY6AnTO#/n&3]4"S2k2
+@gUTj'6Pr2N5=KXT>5;G>-RXb&&a)S*'#(uD+&BGIMRGmV>=[e>P]Q0f0jqtD-O!l!bUlE+s9;YeC@=$
+Di,NO%`3N7P&k2Vid"E1(up"s`5El/M9.@-lD$hlPH0a,!%Tb3TOmX=g^)g=gS?kq^V[%dgg"t-kn;Jk
+MoSGh&C*HG8\nEqXra7eal5@Qb6@,HKV.%=+>fBtaVfW\3=Flh:n<XV%5%%qr_C3N#T.$;>#<nFar#=Z
+*ar=/e$p9>ijgVuf-A"Gb(*Wl$"3tP*s^,j#&J,@-NThO*;1A'"R#b!]0$sZb:Ws@*;uR-magk%8e%EG
+KleH-`,qo-\oVgCTH@mpJ)EK\(<)hrU-P\Z4:MSK41Q=<i3q@so"P"efp;Vc#2V0*mhhHV?LVgceA>c7
+3Z,8k#B3^<Vl_qc.k_4LW-km#nm$ob<D9d%n.^l.8+EjR7V>)M^O"mSd#U3b^[]H;O1LnmCY37/#S3o!
+C^_pqY8N7H)!Q;eRQOU6*a*!_gZNa"O$QN^pcOOJH9=iQ0nsnX@l(l%9,rB#Q>P4e2gh`P7aT([h/TBk
+F;?l34HF!7?/d(t4Sut<]DfMX("2R'pZZpiLMquta/sKuQm7EP:bS+S!V!^]kDJde"N%/X*uO!$oQR5h
+p50M)+'lRl8<3G',Q46aLY&o1[sO4lTUtknPd9=`-B>8Q5li>@l["&In+j2t3:V5sjFV@$XeaT.`84kp
+j9c1#l#e3lP!'"W#)AEn6gnWL=FH.-VhY&&H<hrTn[urQi/E&W9-">&W2d21VIqs(j3jd;**,(L=hsnE
+^fF=agIJT6TP@o_$mhjtk+q#,2"Eb958:"6n=UB;KI6`O!BA]$_a[3nT*4)6LPttoBL)&-[PE(;3CSpG
+pe!/lZYfKW=-B6Mm!)G0(EZYia29(l*WGO&O9#EORY4fXY`f,;[^P.`65!!L4Ws/V9PX3T!"=3,jA/$2
+K35l\*a\Ib<"C7f#`XAQ)O/8)K_V),GM)YkGo4d@FU6n"BN0dhI#niD\cfP_0rm*a#OLaT`i"l`<:CLt
+K<I\nH%n.\d'Lh#n+HfpjtL7E%4\bkZst5M[llIA'+$,o7nY(1ngaK$i:tp6["l-N&l4nA*R+kmd_"^q
+]!].oV(u>ic^Q[O51;i0J%]6.GOCm=#.sM$b9kfBed\m:3'DPP\;H1LrG.peQa1[>PR3l7=?:^P6,R9i
+g-sTu]"`MlOLDjs`3/%7Ns?dpoIa+L=>mhWVZ=@^1cc$2<PoPiQPm%:^9OGS\`1$h_:N77GkIR.i(KrJ
+/'q:&\&Z(d3LQ@/fBB\o[)YXRX<A9j8<D%/R8'C!X8gd^PBi;Y`7$(?nfOfLjqdQ4]FRNU)[([/+>?Gr
+]XfWD-%c\4CGAVVj"6./d<b@D+E,qD!IX3]Z9j_j"]+gm2NE_1qQTf,(:b9XZ[G+PI)uH,gc'U*F[Ek&
+Sc5/:SX<5eoHp=:>h'iQTfiS7UVG.Y$R'n1*I,jG,T&XpD1sKm<O9>_R7^/!=j*C=KU2*bZt`E^R':(G
+g].0!2?q0q6/9\Zft@Vu&N-@-($bCXjO[:QaYU)D0mqOR#_e8Fi>WN3d'!.7I3#cD+VR1.LG--:jE(Z\
+ih4U"Jpj?<pB/eCc#jeP'6/+G^6Y9Um?)bFZr)&SR:M1Q4ht;k;V^A1anMTbjD*G0kLfpNmP/WXSWRXf
+V^G-D%%dT?=;Bs5J3<uC%RB?+%,On42mj/NJ"bbXeQF&s<>".eM&'l(jqh@R>iWQ`A]c3HZ"s!jrRo'"
+%=BG0M'o/FohrA1GqfsC3o[9\#Nhf&Y_HU-32qpA!$'Xgj@hn&?1;MQ#WXLT-XS&Vj_/@Qifa[rA!1B/
+B;g-W[*WKK'0[[TiGIfIGe/`"'Z:SoC6lM1TZo1/U4Fkmq#S1#2mcm%=$3+j!CsS6J6:Pp%XOn`,cCqN
+Iu^u,>khgEd@]LPAF!$Vf)mqo<AjPjAsLNQitJK[qGZM;]M!aSfb=q\:R/Xq\,Kq-kYDt5e>8W%3T:/]
+rFlL-J#Y=Nh>5TPZ/5<j<h8L=:VLOTq@R$EmC3'o>pZ`M?n/AP-R7d$T:F\,JpuO]^R6g,?hcIj077Z]
+CRVBR,E?'gCpbe=/q!B7LQ;(^cT^S$g2PZ_=NbERinrJ_A%V6@0i)sE-bI60jm3AI<f_[fdqWTA[u`U5
+[eC=$L3n+3Pf]un<H7A#Qot='rl(B_FYj$ebN"W=77"s]bOZr"AjY$`eKsZ)hq^ke@6QcF]:%=qIU#V]
+nGUQi55F@\mn;6Fb#QHaES[cR\.RM-&,$$Rbe`*lD!Z<<*1l\De'M=n4F&(%)kSK6$j7@QK.iU7\[jVa
+-]A"ohJSNq#bWG%-N):gP\'O-<;$2_4oE9HbAf5O;WUkiM4EGVja%4*24"<u4THPp`,=0P/#V6;=j0P;
+g]MU[X9[!t!E\=qEuqpR?NX/CNppoWbP$m3Ed>O"b#$uqC\kE=#**HSQu(TC_]tIVa;cIAbh#knbJ>-n
+?#E/l^8aP^M\,54b3::#UThHY3-o)h_A,-h2@;9Rd%L`!@WX%;3GCHYbY:oHc93/-\G6<6W-A&mh-=dK
+SI"n[eXK>OQh*0hH?2"Sic99^BK)5e0XtIum5f/lS8e`hO`BEFJ%>(e27O<q)CK@qoV)!d#;$J_.&*Nk
+47q7(\$sO6c]4!2[[9N:h;2MoI3:alm(\g(2u,j;',s@Z99/92"^_JENO!rD>WZ'%OcD]fN!)"!N\"#a
+gPlMC'?>rp@kmfN6+bB)8l=?C]CLcV6Z^jfTcXu.`t.V)-$dOV^j(2:#/#q<bi6,ZRa0k_Ffb2QP*eM8
+EkAN4>eg67P2r3i8,2kj&'+,XGMY=\9'49lZfJWYHIJF/FnTDRkKCIWQ9;K8BbRC+/gfOiQD6?U89\>I
+EDDqL*FXecFB`PPdF=aJ/O91MErX/2.T+A4a"JDu5XCE869H[=(iJB,((G1Z;(5p8=$g*INQui4&iD.C
+ZD,(pEq7_&JSW;<3?+*62EG[MmFXr,XE's,KWc!P?]Y\jCliE[C/T)"U\muq*q%I.>k9@ed+_RO"-\a7
+Zl-Y6n(t;[1gV>PXi3VAE>g2_]0$O2[oi"h0C;U%n+uXJj"R;g3YU3G3k?[+m@U/s<9qkMQibfU$.8,o
+"f`[pisnk2UU-R#-XL2'LFH%fi^5h(;'+0Gg>B+#0]hIZi9RN[H/<Etk@OP`-,]V+PGNcKJ')nN/7$uD
+R/_du<l\=0n2_VMHb1'i7??0)60aiH.(,#5G4fkbbBgc9!4$C/;OZopV86:11u^C(85s`NNjePph:usK
+`XZ;A?#oX*gg.EDe7<h^je]Q*3_[.ba6B;OL"_8'eN`;ulcOg]'1s)3"cd(rBD*8!/PAg6=rujY,]G^:
+(PB-:gPlX+&72eDRBFf-/%1p_)"^;f056CH>a9JQS3"rOIqN)/4%B=W9>>VLguQOi0huQW01S+&aD^L#
+];QW:V]aK3AM\IIO00_Yk]P;W@W0Z`$b/Grf5Yl>p.\iWCri"S%s`FZhP_j)iM"o`:+hEh,5rJ*:Z`!0
+M@t(ER2g^;#HDr!\g%SS:WMT3VTTXT3JE$#mJ5g$FLBhC"#`(aN9q[EV/E,bQL,@j3/'.T]"?t;Pip,X
+_JG`i"(J3)T!:;0\T#fpV-f6_SVtW"?K\>OP@AA[Z3>EnG'NoNC9V/5)3YS5*ZEkY.EofrRWZb#G[Jk=
+4B1(k'?..$ms1nQ:Tuj'_Ql/o(N[I3jm!n4>rNJC3,Ec?gg[1kfY00Y4QbFuiss&M[tgO'C,LCkDJ)^8
+HU^5/PK-!F\9fB?maSjg-Cm4!<@]r^8E8=,;60#Sj%!o\PqJ#Xf?K]dmo4HKHTG(%AiR'3h.X`Odt/P,
+)gf,?1SfGN]cIER*c3k_+gG5&2/RF&[!U#+S#BiifR7W00KahnS`IueK!3X+)LCDC>FRR#GJ*6Nl(@L<
+U9c[[U)c7un^'E)i*e7,QGVOkj;2Zi)Kna,M`DVVMZp3GjaJ?Alsp6)iTKSX+<(WkX`BZeQi=jf2Tq3r
+Q:BRIT`^<cj`GS/:gS\CG2n*6NW-5S3WQ(,@_6C!9ej#W(GFn;gW&B<R&T1&"?#nCGS&WjNHr,P!?Pgm
+H>@cFg[%5^BeQ;?GF541N9J]0c*eGJRs5n$'G[R'L0\Lfma1V.E7DBT$Cc)Z(ajEOpF<bcV#$O4%W3%=
+m8flmHXU-2p%frak2lu8e)nUoNjjCLUIf@XNNIpeYDn+]G!"2CO`W<J&&;&f*72=8FATOhg;k8gCs7kC
+I_"8Em<m/A:t%V(3=eFc6TG%pUkO)4N\6)E(2J;8?VYeR@eicCaMq+*Ph97d6frQ*j/1\?0=_>%o/4!E
+]2UO(CD79_Du.1.`@n\fmD6mT:m^3(CJWPE6g\Ps\fKdsgI]PbN/sl6SZ7XN.OBq8X7P4fMT9sfZ=618
+fBBC+YN]6NlfIgVY(O+dhjtj9IWJ9p5/7%FXu1#/A@pEs9p"`\__se5bY=2d>/N6aY':;,L\+4HrR.i+
+I_Go5ca<spn_j)(e<HH_8p,9pTskST5)<M2m-'GY:3FV>VRJFYkSd@5/$6$9$F2=[UqPl*kj=k)C=m93
+?U!'8PJ+\k4nSMjHKam3;0HJV5X)P/XLH'%3W7;\<LXcOBp%JF;mCL[;dVT>ZnNJ5dV<.K2Y0@qiHGW.
+WaW)n^3m#c7+kX]ftVo<r,o_UPA-KIjm`R;p7I'!a_\Hnd2emI@#X1J&\#OuGPU`*_T'la\s<.-L>KY0
+<<^+h7#Zmm@4,TX3jc!G^?t\`V[)qcGBuenT!uVHDcX4Mm#(&nVi#u./GVZ=\B*"PGJ:c5f+]e:D\)I=
+?O=<`F9PKLoDh//4Cc>=2)WbH%dl&p0!c-TRk(#"B?&sU6H?dEE5P?OllCU$<p^N4h<_.D3eS[Z.;X0$
+93ub#WaY]EkX^lGVP%ukKOM$Hmsoq[#i+h,270<ndju-pqnmGE;]@>BFI$8(-5J!sj**e29T_CsALMRG
+R:n$7jNJtOE*<^TfbO;5]rlX;H:8U!FZ$*PI]EBTlO+3*K6@5)!0d7KQP9\;gk?qfZSfmoLi(`pZ*@;8
+]W3tGPM^(joNJP)Vh"NR_/#/(NF2mr'4CaeFoYq%<QtkV2TY/$r[`4#?oEq&S19-[&kpsV:C'/fT%jBZ
+<"IBN%k$%u/MQ&)-!r7.!4F$(brM::WWc=&9bgLAONefS=?@]$]A]H6^as2FnXV!eW*pL'i5N'J+KPRK
+,qgHfB8>3mE(/HEHY%73:Vj\cGW<J?%!Ba.5H#C/Xlg7).a%D7j6<d`J*f1PG4*b\!F"`4CYg[1@Wg]B
+(P&P4B)ktX8tNtj':\Z\4"-;X4K36b\]'MNrQ4=#8G>(3$DVJ!e$@@RE[h&,g?=Mu\N2kGZN(u@(D_hm
+=_KFradcIbDsZ\0!^LM42-R5JlL=G9"ebM+Y"85cgI'fIS>kdig$/UJ-%]WXU.=@\o,]%FkdhMq'^CiV
+:*DU0W8WVP*oF1b*NMR3p>%.`+s68PPpYOn]3l>e+e2dO99'!g0l#c=5+)+"^r5J)5_A/i3#ke>i<fm!
+;u'^o0A:Pjh"ja(T+Zh]5('+X58lq1^2nGVLGQi$Y]=2*fgcEr%li*6lB2YYefc%3.7lko5-f_),9GZg
+%)C\?;'?\19Yc[F?F*18:r9b6/GBuU9gZt^4%BVJ7k^b->Zs"7VX>'>6&);?#m7"g^rY?6*T1d&E?fiH
+0UrM6@.J=cl^(=42o;SQqOL]E&PuHfS4]C&HHuNsh6S8fo,6I"?ZaO42BKrqL^Ai9lpVGpqC%h@fb->9
+h>Xj&OQ2q/Rh!WB\?#gE3IR2%fVZYWU0rp9%toAUYiOW9+Qa78HE)0@pEN,4/l1E,!AY@3)lIn$\fm7&
+meMm0,Cn&YWXJCQOI:)ed/uXMq@(:I_rf"<n$C+i#d%nZ"9m[R]8(Y-7:p_q5KV;76T55%Qu;b#@XJ_9
+W2qu6,4Pd=9\,Wo;kRqE.]c[Gqm>G5Zm/773D"PTVN>,0R0SUK2-o`@4s*I>b&mM.@2b,)9jH*1#)K(<
+FKMX89ioUt%pVPSSX]9H/IX2gN.!^Yr#"q=Y4b_eNdBfm2/(=t6\%?t/lOAE:0eQQMD"OFq(^e5VP5#Y
+/spb:BsV-fdY0Sp(7IL[pu2CBJuNGA*l1gc!Or;3WOf*;K'>N69HLG":uRQ1-NRF*H%62J]4U,UWFVX)
+9e[=B(DBK]DTA7)_,[(U$`9)7qH&&d3CgpH`8#sd"0S4J2If%na-%&9e7mk.O.N,hcjbq-.KFLtJYbZ0
+M+aEZXtjD-&5IU1*uro9]&4bX:I]O.DV"=YE#:fQ9LR+F<>S+Z,&kP!9OeZ^A*qFOik(_XXSa5FMJ9(m
+@>P'1j_0</Y0qFF"H/=g+Ej33-1B]]RFqa<S!E,!h:X5lpjuJJX%&6:RO*lVo#%Q[2NP%`hR]Pf;<CF6
+'4?Hhg<JpG!9cdl;6U-P?'YI+(Cl;KA49I=CD(bkB>JD[lLkoClCeU-n:Y\%,R\&>d_n5oAh)UHdMWG'
+Dn8#k8?_+t8%[eqILVZ(Z6'pGZL%'MT6*rm!SEFs`[o#tVDQgGbtTrL^Ubg!QX?)f>\L4ad6hL`;QXoG
+@9S@pZ121#@4aY.#RA4e87U6QRW]"[&36ak)J-Khg$*b_Q&YUXqn8n>bj`u&O^n0\cGZ[c*#[Or`tcAl
+_nFCDFB-NY3L]2hH_7'E?Ws`=/^%^am;j7\q]$Ybq]'S!U>FiipNWpII?(0dQbG:p-44U^_r9J83!%gt
+^cP=UF\]fHRF_'li#fuB"njr[Pd:YMk@d^+n$UJ=c*+t?kGY7(m<oK?9&6iHb/8Oeq]%3a[YF0jaM_WX
+F+BHk@=`ie")XC?")OU)8X0*97uOP/g-/#bg-r;q%dWCS9HFaPq]+J(CS/Lsp-)",_bo#L#;Y[.!(GUF
+PkuFP\qd$/Je63k8#,>"hWJjfpGktKpGnZV2rEf6:Ai!nLK4**k@hcF$u5;C#)%BRB$dh*or'`T:"nU5
+27^p"paR3A3^=f=)IJ\oBn`l-MbE,\\[jNq72s,BM#)T+$lBCl#%NFSUteOG/;:B0-<KNlcFQMe[fs[O
+2FRGI#MY=eWdsgWJ3DHX(]a"tJ8lQ;f/0ZQ@G%#!@u@0C<!l!o<4QJ'.Ug"lI3mUK\@lRE=H^I`=$;`b
+S;NkC*n<KA/"X1cqAO=aU=Q'%cb2g,kaD!X1:?4c?qet2GKkM,r[p>61]QA<VR@ih*d!kA4'^YfTKgBL
+:.W5ek^,=U,Uc4fE=UkHiqFd,@&VIi3'*g/B/F8>kus)+LMQ]pis.Jl1X>`;#d4m.!-j-<G)5.]VPQZG
+WjDhbmShMA>gq>=g=4;[Nt!BG0]QiT0`qSmhCs0:*XddKaKK<5!4&eb)7#olUXo-jeoL4'G95a<gV_<(
+\T^iPGj/5@VA<O1LdCmYjQr<S/RV:qK@6Oe/9ZFO\<Z#Z<U@gr!S9h9.`HJES]aQ=gs3k?cEo^XO2VE=
+RV<[/-N`GZH4)&[rKDc<oGAq3T*'%,Y#$&WEY&;ge>!ao^#f>uGL8-fQRh!3*fQYM<*dbtNJYp(H<Y]6
+2X;NQCU7.J`d>%;R[ZRsCj*>?kB"6IjN.)!D7b"0'u[P5BCS!=gVpHJhGRueD5V9N"Dcq?`QJ;*rjqtr
+L$(Y,T((0`KT'b+45?=9*akJ^rj?T$>OH.1fh2"`k%VG.:=f`^^NinNrS&E1cKI??ek=V,Zbo^+$a@n<
+.5(61_25R4N+m+on[:AbS';F=cWPd82WO+=,Q+h7BMK"[9'?@i#P_nPoqN:>2HRNtFZ?T$6'YBIlG]e;
+Il>smI.IR0>Z^@k,'i\6jft[J^nBP"TcT$UU;`9#4%dYPnU="cPe1eL7T'bngURUR"#phSU$b'LS6>OA
+eVPsR(7eB9pWX1e_,Nep[D6:f23^%J[@S#IK/o?qpYnl$[8KiAq,h;mqmqDS9%"UJ8-d!`?ZZWgW2CaF
+Qias%187%h:__"<MU/GsA!:uc]lD%<s2=!p?DjuiV7#cOj>C3FVDFl[%,/iglnX!Y=mRn$lehaU,Tg6P
+nSPL1XL<:[7u-5M/Pr*@K`gH7;T\;S')lG;[CQ<Jl\8'(fN"?A+S@1I.Q]N*I#GS*2?ilqVT*l"Rhl\3
+(0S3&0c#bNPruU[#]HN7SE`"J57gn9VBr]==Rcl9f?7+.e6mjf'j?,*YqX[:crsdQeb,]7V"0/E6@RT.
+=`*3a2\db6(sJYeD.*[^T)^in<G2245H>!fDlCsiP9Ir$iOd81qQW#"=*Zo?nUNF4U7E5c#@'XaGHPl`
+UbTql);+k&1+N)_"#FV!C!,<r[Bdp!d(I:@rGG!:^jRVkL,ddQmO[L0rpQo#J`.n#^?nm>%nJ<+ki/?1
+l;u:ZZ!MFn\Apm>a@+(=Gn/Z6Je'6]l3?k<&"G9M(LE.sZ2f^O2+3"`ohaDTHhYAnHt.]`S$FS3MK'S;
+&6H%?^\P,hN7u7F>QoSlHI;k^%gq6`1Z'd_8ad@0*4bE$H5cV0'QohslA4p!b/_=Gs)_b/?fN[`\XW(,
+)a6-P9)8R<bX'8E<t8MS8aIFg1".WX)ZF=D*^C4JIr6)OaE7gW.t_8b4*aq%S+N/t.!!pHr?D$X#:3M?
+D]Cpk>]sL=&L6ju4TuTneV3Uk$N[Nik_B?724A4D9Y=f@A#DDQ_=MPIYJ]Q2_+JKf:g\M2[mTR#0]j"?
+HXJFob*e:H8>ePXX![t@M+_.IO1Mn4*6fWuBBuECJLBLgifW3>Hjk(G=YQ#+Y;papI#!"mFOi.hFi(-q
+cqKHfQVpWGj?#_]!tfXR\tm[.hi4[CkTF0LWA3tuG]C[H0:XV7]#MRINV>EU=`+_@n/ceaaao+dH1#]I
+Y]8(#no;.uk<7,[r^X]maZnU+O.+sQblU)!j7Q"a0eUGo6OFeNF13K_@!>+Nd[O08Dl7\>-bJN&8WSD+
+)s>D;I&W^C:X"VB3Mu/_.piJ3UFG=mXhN`(45TjfkJ`;0.@]b&&dMj/SXHY%bpZM^/m"$2bVH+$meENg
+oZbadnL.*-gTR+ArGR2A`:8-/A;@[7FQ5_pqt6*mn'4>dA,Pe^mrnL*G"L;l1=th=I[b,N8@md<YFG/(
++277>J)9K<DYbAslc^&j^M\'2L\K9srHcSG\(=?UrI=cgP=K,&]pfj]5R!oj^37E7l1ckrk$0"=0F*n$
+/fnUSoR.5X%D;UDFP$FDhaX,^bEZ^FaH8Q;ES0VA&oIJqH+H-O+#\jfq#&W,ru^%-qbc>K2"9nQ9)cU)
+cl8oJ;q>Ho`pc>.81g5t4C_$=[f5<rs06>:&)[@>\h<>"~>
+endstream
+endobj
+7 0 obj
+   21431
+endobj
+3 0 obj
+   << 
+      /Parent null
+      /Type /Pages
+      /MediaBox [0.0000 0.0000 831.00 792.00]
+      /Resources 8 0 R
+      /Kids [5 0 R]
+      /Count 1
+   >>
+endobj
+9 0 obj
+   [/PDF /Text /ImageC]
+endobj
+10 0 obj
+   << 
+      /S /Transparency
+      /CS /DeviceRGB
+      /I true
+      /K false
+   >>
+endobj
+11 0 obj
+   << 
+      /Alpha1
+      << 
+         /ca 1.0000
+         /CA 1.0000
+         /BM /Normal
+         /AIS false
+      >>
+   >>
+endobj
+8 0 obj
+   << 
+      /ProcSet 9 0 R
+      /ExtGState 11 0 R
+   >>
+endobj
+xref
+0 12
+0000000000 65535 f 
+0000000015 00000 n 
+0000000315 00000 n 
+0000022174 00000 n 
+0000000445 00000 n 
+0000000521 00000 n 
+0000000609 00000 n 
+0000022150 00000 n 
+0000022628 00000 n 
+0000022344 00000 n 
+0000022383 00000 n 
+0000022485 00000 n 
+trailer
+<< 
+   /Size 12
+   /Root 2 0 R
+   /Info 1 0 R
+>>
+startxref
+22701
+%%EOF

fsa_cbd_composition/fsa_cbd_simulator/models/bouncingball.py

@@ -0,0 +1,117 @@
+from CBDMultipleOutput.Source.CBD import ConstantBlock, NegatorBlock, \
+    IntegratorBlock, CBD, ProductBlock, AdderBlock
+from fsa_cbd_weaved_classes import InputConstantBlock, CBDState, WhenCrossesZeroTrigger
+from fsaclasses import FSAModel, Transition, Event, State
+
+
+class BouncingBallFSA(FSAModel):
+    def __init__(self):
+        initial = CBDState("Initial", BouncingBallInitial("BouncingBallInitial"))
+        freeFall = CBDState("FreeFall", BouncingBallFreefall("BouncingBallFreefall"))
+        collision = CBDState("Collision", BouncingBallCollision("BouncingBallCollision"))
+        kicked = CBDState("Kicked", BouncingBallKicked("BouncingBallKicked"))
+        end = State("End", True)
+        
+        initial2Freefall = Transition("Initial2Freefall", initial, freeFall)
+        freefall2Collision = Transition("Freefall2Collision", freeFall, collision)
+        freefall2Collision.trigger = WhenCrossesZeroTrigger("x", up_direction=False);
+        collision2Freefall = Transition("Collision2Freefall", collision, freeFall)
+        freefall2Kicked = Transition("Freefall2Kicked", freeFall, kicked)
+        freefall2Kicked.trigger = Event("kick");
+        kicked2Freefall = Transition("kicked2Freefall", kicked, freeFall)
+        freefall2End = Transition("Freefall2End", freeFall, end)
+        freefall2End.trigger = Event("enough");
+        
+        self.states = [
+                       initial,
+                       freeFall,
+                       collision,
+                       kicked,
+                       end
+                       ]
+        
+        self.initialState = initial
+        
+        self.transitions = [
+                            initial2Freefall,
+                            freefall2Collision,
+                            collision2Freefall,
+                            freefall2Kicked,
+                            kicked2Freefall,
+                            freefall2End
+                            ]
+        
+       
+    
+        
+        
+
+class BouncingBallFreefall(CBD):
+    def __init__(self, blockName, delta_t = 0.01):
+        CBD.__init__(self,blockName, input_ports=[], output_ports=["out_v", "out_x"])
+        
+        self.addBlock(InputConstantBlock(block_name="in_x"))
+        self.addBlock(InputConstantBlock(block_name="in_v"))
+        
+        self.addBlock(ConstantBlock(block_name="gravity", value=-9.81))
+        self.addBlock(ConstantBlock(block_name="delta", value=delta_t))
+        
+        self.addBlock(IntegratorBlock(block_name="intgv"))
+        self.addBlock(IntegratorBlock(block_name="intvx"))
+        
+        self.addConnection("delta", "intgv",  input_port_name="delta_t")
+        self.addConnection("delta", "intvx",  input_port_name="delta_t")
+        self.addConnection("in_v", "intgv",  input_port_name="IC")
+        self.addConnection("in_x", "intvx",  input_port_name="IC")
+        
+        self.addConnection("gravity", "intgv")
+        self.addConnection("intgv", "intvx")
+        self.addConnection("intgv", "out_v")
+        self.addConnection("intvx", "out_x")
+    
+    def setDeltaT(self, deltaT):
+        CBD.setDeltaT(self, deltaT)
+        self.getBlockByName("delta").setValue(deltaT);
+    
+    
+
+class BouncingBallInitial(CBD):
+    def __init__(self, blockName, delta_t=0.01):
+        CBD.__init__(self,blockName, input_ports=[], output_ports=["out_v", "out_x"])
+        
+        self.addBlock(ConstantBlock(block_name="init_velocity", value=15.0))
+        self.addBlock(ConstantBlock(block_name="init_position", value=10.0))
+        
+        self.addConnection("init_velocity", "out_v")
+        self.addConnection("init_position", "out_x")
+    
+
+
+class BouncingBallCollision(CBD):
+    def __init__(self, blockName, delta_t=0.01):
+        CBD.__init__(self,blockName, input_ports=[], output_ports=["out_v"])
+        
+        self.addBlock(InputConstantBlock(block_name="in_v"))
+        
+        self.addBlock(ConstantBlock(block_name="coeficient", value=-0.8))
+        self.addBlock(ProductBlock(block_name="mult"))
+        
+        self.addConnection("in_v", "mult")
+        self.addConnection("coeficient", "mult")
+        self.addConnection("mult", "out_v")
+
+
+class BouncingBallKicked(CBD):
+    def __init__(self, blockName, delta_t=0.01):
+        CBD.__init__(self,blockName, input_ports=[], output_ports=["out_v"])
+        
+        self.addBlock(InputConstantBlock(block_name="in_v"))
+        
+        self.addBlock(ConstantBlock(block_name="kick_impact", value=20))
+        self.addBlock(AdderBlock(block_name="sum"))
+        
+        self.addConnection("in_v", "sum")
+        self.addConnection("kick_impact", "sum")
+        self.addConnection("sum", "out_v")
+
+

fsa_cbd_composition/fsa_cbd_simulator/plotSignals.r

@@ -0,0 +1,54 @@
+library(ggplot2)
+library(cowplot)
+
+mydata_signals = read.csv("./signals.csv")
+mydata_events = read.csv("./events.csv")
+
+total <- merge(mydata_signals,mydata_events,by="fsatime", all=TRUE)
+
+pe <- ggplot(data=total , aes(x=fsatime, y=Event, group=1)) +
+  geom_point(na.rm = FALSE) +
+  ylab("Event") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("Event", labels = waiver(), limits=c("when(x +-)", "kick")) +
+  theme(axis.title.y=element_text(vjust=-4))
+
+ps <- ggplot(data=total , aes(x=fsatime, y=fsastate, group=1)) +
+  geom_line() +
+  ylab("State") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("State", labels = waiver(), limits=c("Initial", "FreeFall", "Collision", "Kicked")) +
+  theme(axis.title.y=element_text(vjust=-2))
+
+px <- ggplot(data=total , aes(x=fsatime, y=x, group=1)) +
+        geom_line() +
+        ylab("Height (m)") + 
+        xlab("Time (s)") +
+        theme(axis.title.y=element_text(vjust=-6))
+
+pv <- ggplot(data=total , aes(x=fsatime, y=v, group=1)) +
+        geom_line() +
+        ylab("Velocity (m/s)") + 
+        xlab("Time (s)") +
+        theme(axis.title.y=element_text(vjust=-6))
+
+pt <- ggplot(data=total , aes(x=fsatime, y=current_cbdtime, group=1)) +
+        geom_point() +
+        ylab("CBD Time (s)") +
+        xlab("FSA Time (s)") +
+        scale_y_continuous(limits=c(0, 10)) +
+        scale_x_continuous(limits=c(0, 10)) +
+        theme(axis.title.y=element_text(vjust=-6))
+
+multiplot <- plot_grid(pe, ps, px , pv, pt, nrow = 3, ncol = 2, align = "v")
+px_pv_plot <- plot_grid(px, pv, nrow=1, ncol=2, align="h")
+ntplot <- plot_grid(pt, nrow=1, ncol=1, align="v")
+col_plot <- plot_grid(pe, ps, px , pv, pt, nrow = 5, ncol = 1, align = "v")
+row_plot <- plot_grid(pe, ps, px , pv, pt, nrow = 1, ncol = 5, align = "h")
+
+save_plot("plots.pdf", multiplot, nrow = 3, ncol = 2, base_aspect_ratio = 1.2)
+save_plot("ntplot.pdf", ntplot, nrow=1, ncol=1, base_aspect_ratio = 1)
+save_plot("bbplots_vertical.pdf", col_plot, nrow=5, ncol=1, base_aspect_ratio = 1.0)
+save_plot("bbplots.pdf", row_plot, nrow=1, ncol=5, base_aspect_ratio = 1.0)
+save_plot("bb_vhplots.pdf", row_plot, nrow=1, ncol=2, base_aspect_ratio = 1.0)
+

fsa_cbd_composition/fsa_cbd_simulator/plotSignals_horizontal.r

@@ -0,0 +1,48 @@
+library(ggplot2)
+library(cowplot)
+
+mydata_signals = read.csv("./signals.csv")
+mydata_events = read.csv("./events.csv")
+
+total <- merge(mydata_signals,mydata_events,by="fsatime", all=TRUE)
+
+vertical_adjust <- 1
+label_size <- 20
+
+pe <- ggplot(data=total , aes(x=fsatime, y=Event, group=1)) +
+  geom_point(na.rm = FALSE) +
+  ylab("Event") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("Event", labels = waiver(), limits=c("when(x +-)", "kick")) +
+  theme(axis.title.y=element_text(vjust=vertical_adjust), axis.title=element_text(size=label_size,face="bold"))
+
+ps <- ggplot(data=total , aes(x=fsatime, y=fsastate, group=1)) +
+  geom_line() +
+  ylab("State") + 
+  xlab("Time (s)") + 
+  scale_y_discrete("State", labels = waiver(), limits=c("Initial", "FreeFall", "Collision", "Kicked")) +
+  theme(axis.title.y=element_text(vjust=vertical_adjust), axis.title=element_text(size=label_size,face="bold"))
+
+px <- ggplot(data=total , aes(x=fsatime, y=x, group=1)) +
+        geom_line() +
+        ylab("Height (m)") + 
+        xlab("Time (s)") +
+        theme(axis.title.y=element_text(vjust=vertical_adjust), axis.title=element_text(size=label_size,face="bold"))
+
+pv <- ggplot(data=total , aes(x=fsatime, y=v, group=1)) +
+        geom_line() +
+        ylab("Velocity (m/s)") + 
+        xlab("Time (s)") +
+        theme(axis.title.y=element_text(vjust=vertical_adjust), axis.title=element_text(size=label_size,face="bold"))
+
+pt <- ggplot(data=total , aes(x=fsatime, y=current_cbdtime, group=1)) +
+        geom_point() +
+        ylab("CBD Time (s)") +
+        xlab("FSA Time (s)") +
+        scale_y_continuous(limits=c(0, 10)) +
+        scale_x_continuous(limits=c(0, 10)) +
+        theme(axis.title.y=element_text(vjust=vertical_adjust), axis.title=element_text(size=label_size,face="bold"))
+
+row_plot <- plot_grid(pe, ps, px , pv, pt, nrow = 1, ncol = 5, align = "h")
+save_plot("bbplots.pdf", row_plot, nrow=1, ncol=5, base_aspect_ratio = 1.0)
+

fsa_cbd_composition/fsa_cbd_simulator/weaved_cbd_fsa_lib.py

@@ -0,0 +1,169 @@
+'''
+@author: Claudio Gomes, Bruno Barroca and Sadaf Mustafiz
+'''
+
+from fsa_cbd_weaved_classes import WhenCrossesZeroTrigger, InputConstantBlock,\
+	CBDState
+from CBDMultipleOutput.Source.CBD import OutputPortBlock
+import numpy
+import os
+import csv
+from fsaclasses import Event, After
+
+class FSACBDLib():
+	BLOCK_NAME_OUT = "out_"
+	OUTPUT_SIGNALS = "./signals.csv"
+	OUTPUT_EVENTS = "./events.csv"
+		
+	def __init__(self):
+		pass
+	
+	def getTriggeredWhenTransition(self, fsaCbdModel, currentFSAState, globalState, previousGlobalState):
+		'''
+		This method will check whether there is any transition triggered by a zero crossing detection and if so,
+		if that zero crossing has in fact occurred when comparing the new globalState with the previousGlobalState.
+		'''
+		triggeredTransiton = None
+		
+		for t in fsaCbdModel.transitions:
+			if t.source == currentFSAState and isinstance(t.trigger,WhenCrossesZeroTrigger):
+				varNameToCheck = t.trigger.varname
+				if varNameToCheck in globalState and varNameToCheck in previousGlobalState:
+					if t.trigger.up_direction and previousGlobalState[varNameToCheck] <= 0 and 0 < globalState[varNameToCheck] :
+						triggeredTransiton = t
+						break
+					if not t.trigger.up_direction and globalState[varNameToCheck] < 0 and 0 <= previousGlobalState[varNameToCheck] :
+						triggeredTransiton = t
+						break
+		
+		assert triggeredTransiton == None or t.source == currentFSAState
+		
+		return triggeredTransiton
+	
+	def updateGlobalState(self ,globalState, cbdModel, cbdTime):
+		'''
+		The globalState is a dictionary mapping variable names to values.
+		This function will get the signals for the outputPorts in the cbdModel and then
+		update the globalState with the values of the outputPorts at time cbdTime
+		'''
+		for block in cbdModel.getBlocks():
+			if (isinstance(block, OutputPortBlock)):
+				port = block.getBlockName()
+				signal = block.getSignal()
+				# Convention: port is of the form "out_varName" to represent the global varName
+				assert port.startswith(self.BLOCK_NAME_OUT), "Convention violated for output port: " + str(port)
+				varName = self.stripConventionOutname(port)
+				assert len(varName)>0 , "Convention violated for output port: " + str(port)
+				
+				mostRecentSignal = signal[-1]
+				
+				assert numpy.isclose(mostRecentSignal.time,cbdTime, 1e-05, 1e-08), "Signal as not been computed up to time " + str(cbdTime)
+				
+				signalValue = mostRecentSignal.value
+				globalState[varName] = signalValue
+	
+	def stripConventionOutname(self, name):
+		return name.replace(self.BLOCK_NAME_OUT, "", 1)
+	
+	def updateCBDState(self, globalState, cbdModel):
+		'''
+		The globalState is a dictionary mapping variable names to values.
+		
+		This function is to be called when initializing the cbdModel.
+		This function will iterate the input blocks of the CBD, which have conventioned name as "in_varName" and it will set the values for those blocks. 
+		'''	
+		for block in cbdModel.getBlocks():
+			if isinstance(block, InputConstantBlock):
+				assert block.getBlockName().startswith("in_"), "Convention violated for input block of the CBD: " + str(block.getBlockName())
+				varName = block.getBlockName().replace("in_", "", 1)
+				assert len(varName)>0 , "Convention violated for input block of the CBD: " + str(block.getBlockName())
+				assert varName in globalState, "Input block not initialized before: " + str(block.getBlockName())
+				
+				block.setValue(globalState[varName])
+		
+		
+	def dumpGlobalState(self, fsaCbdModel, globalState, fsaTime, fsaState):
+		create_header = not os.path.exists(self.OUTPUT_SIGNALS);
+		
+		if create_header:
+			self.addRemainingSignals(globalState, fsaCbdModel)
+		
+		# It is not a good idea to write this directly to the global state but it is more efficient.
+		
+		globalState["fsatime"] = fsaTime
+		
+		if isinstance(fsaState, CBDState):
+			assert fsaState.cbd != None
+			if fsaState.cbd.getClock() != None:
+				globalState["current_cbdtime"] = fsaState.cbd.getClock().getTime()
+			else:
+				# Clock not yet initialized. Can happen.
+				globalState["current_cbdtime"] = -1.0
+		else:
+			globalState["current_cbdtime"] = -1.0
+		
+		globalState["fsastate"] = fsaState.name
+		
+		with open(self.OUTPUT_SIGNALS, "a") as csvFile:
+			writerCsv = csv.DictWriter(csvFile, fieldnames=globalState.keys())
+			if create_header:
+				writerCsv.writeheader()
+			writerCsv.writerow(globalState)
+	
+	def addRemainingSignals(self, stateDict, fsaCbdModel):
+		
+		for state in fsaCbdModel.states:
+			if (isinstance(state, CBDState)):
+				for block in state.cbd.getBlocks():
+					if isinstance(block, OutputPortBlock):
+						varName = self.stripConventionOutname(block.getBlockName())
+						if not varName in stateDict:
+							stateDict[varName] = None
+		
+		
+		return stateDict
+	
+	def dumpDiscreteEvent(self, fsaCbdModel, fsaTime, fsa_currentState, fsa_selectedTransition):
+		create_header = not os.path.exists(self.OUTPUT_EVENTS);
+		
+		event = None
+		if (fsa_selectedTransition != None):
+			if fsa_selectedTransition.trigger != None:
+				if isinstance(fsa_selectedTransition.trigger, Event):
+					event = fsa_selectedTransition.trigger.name
+				elif isinstance(fsa_selectedTransition.trigger, After):
+					event = "after("+str(fsa_selectedTransition.trigger.expression)+")"
+				elif isinstance(fsa_selectedTransition.trigger, WhenCrossesZeroTrigger):
+					event = "when("+str(fsa_selectedTransition.trigger.varname)+" " + ("-+" if fsa_selectedTransition.trigger.up_direction else "+-") + ")"
+		
+		if (event != None):
+			with open(self.OUTPUT_EVENTS, "a") as csvFile:
+				eventDict = {"fsatime" : fsaTime , "Event" : event}
+				writerCsv = csv.DictWriter(csvFile, fieldnames=eventDict.keys())
+				if create_header:
+					writerCsv.writeheader()
+				writerCsv.writerow(eventDict)
+				
+				
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+				

fsa_cbd_composition/fsa_cbd_simulator/weaved_cbd_fsa_simulator.sccd

@@ -0,0 +1,326 @@
+Diagram(name = 'Weaved_FSA_CBD_Simulator_Manual',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Manually woven CBD and FSA simulators with the FSA being the dominant.'):
+    Top {
+		import copy
+        from CBD_Controller import CBDController
+		import Options
+		from fsa_cbd_weaved_classes import CBDState
+		from weaved_cbd_fsa_lib import FSACBDLib
+    }
+
+    Class(name = 'Weaved_CBD_FSA_Simulator', default = True):
+        Attribute(name = 'fsa_timestep')
+		Attribute(name = 'fsa_elapsed')
+		Attribute(name = 'fsa_currentState')
+		Attribute(name = 'fsa_logicalTime')
+		Attribute(name = 'fsa_currentEvent')
+		Attribute(name = 'fsa_selectedTransition')
+		Attribute(name = 'fsa_eventList')
+		
+		Attribute(name='cbd_iteration')
+        Attribute(name='cbd_strongComponentList')
+        Attribute(name='cbd_currentCompIdx')
+        Attribute(name='cbd_clock')
+        Attribute(name='cbd_options')
+        Attribute(name='cbd_delta')
+        Attribute(name='cbd_cbdController')
+		Attribute(name='cbd_depGraph')
+		
+		Attribute(name='weaved_delta')
+        Attribute(name='weaved_processing_cbd')
+        Attribute(name='weaved_ended_cbd')
+		Attribute(name='weaved_model')
+        Attribute(name='weaved_step_executed')
+        Attribute(name='weaved_global_state')
+        Attribute(name='weaved_previous_global_state')
+        Attribute(name='weaved_triggered_when_transition')
+        Attribute(name='weaved_lib')
+        
+		Method fsa_processEvent(event) {
+			if (event != None):
+				self.fsa_eventList->popEvent(event)
+				event.processed = True
+			end
+		}
+		
+		Method fsa_getInputEventAt(time) {
+			return self.fsa_eventList->getInputAt(time)
+		}
+		
+		Method cbd_maxIterationsReached() {
+			return self.cbd_iteration >= self.cbd_options->getMaxIterations()
+        }
+		
+		Method cbd_hasNextStrongComponent() {
+			return (self.cbd_currentCompIdx + 1) < len(self.cbd_strongComponentList)
+        }
+		
+		Method cbd_currentComponentIsCycle() {
+            return self.cbd_cbdController->componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+        }
+		
+		Method updateGlobalState() {
+			self.weaved_previous_global_state = copy->deepcopy(self.weaved_global_state)
+            self.weaved_lib->updateGlobalState(self.weaved_global_state, self.fsa_currentState.cbd, self.cbd_clock)
+        }
+		
+		Method updateCBDState() {
+            self.weaved_lib->updateCBDState(self.weaved_global_state, self.fsa_currentState.cbd)
+        }
+		
+		Method getTriggeredWhenTransition() {
+            return self.weaved_lib->getTriggeredWhenTransition(self.weaved_model, self.fsa_currentState, self.weaved_global_state, self.weaved_previous_global_state)
+        }
+		
+        Constructor(cbd_options, amodel, fsa_events) {
+            self.weaved_lib = FSACBDLib()
+			
+			self.cbd_options = cbd_options
+			self.cbd_delta = self.cbd_options->getDeltaT()
+			
+			self.weaved_model = amodel
+			self.fsa_eventList = fsa_events
+			self.fsa_timestep = 1.0
+        }
+		
+        StateMachine:
+            initial = 'FSA_Start'
+			final = 'FSA_End'
+			State('FSA_Start'):
+				Transition(target='../FSA_Check'):
+					Actions {
+						self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+						self.fsa_logicalTime = 0.0
+						self.fsa_elapsed = 0
+						self.fsa_timestep = self.weaved_delta
+						self.fsa_currentState = self.weaved_model.initialState
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						self.weaved_global_state = dict()
+						self.weaved_previous_global_state = dict()
+					}
+			State('FSA_Check'):
+				Transition(target='../FSA_Processing'):
+					guard = { self.fsa_currentState.final == False and not isinstance(self.fsa_currentState, CBDState)}
+					Actions {
+						print('going to fsa process... ')
+					}
+				Transition(target='../ProcessingCBD'):
+					guard = { self.fsa_currentState.final == False and isinstance(self.fsa_currentState, CBDState)}
+					Actions {
+						print('going to cbd process... ')
+						self.weaved_step_executed = False
+					}
+				Transition(target='../FSA_End'):
+					guard = { self.fsa_currentState.final == True }
+					Actions {
+						print('going to end... ')
+					}
+				OnEnter {
+					print("Attempting to read event: ")
+					self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+					self.fsa_selectedTransition = self.weaved_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+					
+					print("Read event: " + str(self.fsa_currentEvent))
+					print("Selected transition: " + str(self.fsa_selectedTransition))
+				}
+			State('FSA_Processing'):
+				Transition(target='../FSA_Check'):
+					guard = {self.fsa_selectedTransition != None}
+					Actions {
+						self.fsa_currentState = self.fsa_selectedTransition.target
+						self.fsa_elapsed = 0
+						self->fsa_processEvent(self.fsa_currentEvent)
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						
+						self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+						self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+						
+						print("changing to state: ")
+						print(self.fsa_currentState->getName())
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+				Transition(target='../FSA_Check'):
+					guard = {self.fsa_selectedTransition == None}
+					Actions {
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+			State('ProcessingCBD'):
+				Transition(target='../FSA_Check'):
+					guard = {self.fsa_selectedTransition != None and self.weaved_processing_cbd and (self.weaved_step_executed or self.weaved_ended_cbd)}
+					Actions {
+						self.fsa_currentState = self.fsa_selectedTransition.target
+						self.fsa_elapsed = 0
+						
+						self->fsa_processEvent(self.fsa_currentEvent)
+						
+						self.weaved_processing_cbd = False
+						self.weaved_ended_cbd = False
+						
+						self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+						self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+						
+						print("changing to state: ")
+						print(self.fsa_currentState->getName())
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+					}
+				Transition(target='../FSA_Check'):
+					guard = {self.fsa_selectedTransition == None and self.weaved_processing_cbd and (self.weaved_step_executed or self.weaved_ended_cbd)}
+					Actions {
+						self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+						self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+						print("Going to FSA_Check")
+						print(self.fsa_logicalTime)
+						print(self.fsa_elapsed)
+						
+					}
+				Transition(target='../CBD_Initialize'):
+					guard = {not self.weaved_processing_cbd}
+					Actions {
+						self.cbd_delta = self.weaved_delta
+						self->updateCBDState()
+					}
+				Transition(target='../CBD_CheckTerminationCondition'):
+					guard = {self.weaved_processing_cbd and not self.weaved_ended_cbd and not self.weaved_step_executed}
+					Actions {
+						self.cbd_clock = self.cbd_clock + self.cbd_delta
+						self.cbd_iteration = self.cbd_iteration + 1
+						self.cbd_cbdController->advanceTimeStep()
+						print("CBD clock: " + str(self.cbd_clock))
+						print("CBD iteration: " + str(self.cbd_iteration))	
+					}
+			State('CBD_Initialize'):
+				Transition(target='../CBD_CheckTerminationCondition'):
+					Actions {
+						print('Transition to CBD_CheckTerminationCondition')
+					}
+				OnEnter {
+					print('Performing initialization...')
+					self.cbd_iteration = 0
+					self.cbd_clock = 0.0
+					self.cbd_cbdController = CBDController(self.fsa_currentState.cbd,self.cbd_delta)
+					self.cbd_cbdController->initSimulation()
+					print("CBD clock: " + str(self.cbd_clock))
+					print("CBD iteration: " + str(self.cbd_iteration))
+				}
+			State('CBD_CheckTerminationCondition'):
+				Transition(target='../CBD_CreateDependencyGraph'):
+					guard = {not self->cbd_maxIterationsReached()}
+					Actions {
+						print('Transition to CBD_CreateDependencyGraph')
+					}
+				Transition(target='../CBD_SimulationComplete'):
+					guard = {self->cbd_maxIterationsReached()}
+					Actions {
+						print('Transition to CBD_SimulationComplete')
+					}
+			State('CBD_CreateDependencyGraph'):
+				Transition(target='../CBD_IsolateStrongComponents'):
+					Actions {
+						print('Transition to CBD_IsolateStrongComponents')
+					}
+				OnEnter {
+					self.cbd_depGraph = self.cbd_cbdController->createDepGraph(self.cbd_iteration)
+				}
+			State('CBD_IsolateStrongComponents'):
+				Transition(target='../CBD_ExecuteSimulationStep'):
+					Actions {
+						print('Transition to CBD_ExecuteSimulationStep')
+						self.cbd_currentCompIdx = -1
+					}
+				OnEnter {
+					print('Performing strong components isolation...')
+					self.cbd_strongComponentList = self.cbd_cbdController->createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+					print('Performing strong components isolation... DONE')
+				}
+			State('CBD_ExecuteSimulationStep'):
+				initial = 'CheckNextComponent'
+				State('CheckNextComponent'):
+					Transition(target='../CheckCycle'):
+						guard = {self->cbd_hasNextStrongComponent()}
+						Actions {
+							print('Transition to CheckCycle')
+							self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+						}
+					Transition(target='../../ProcessingCBD'):
+						guard = {not self->cbd_hasNextStrongComponent()}
+						Actions {
+							self->updateGlobalState()
+							self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							self.weaved_triggered_when_transition = self->getTriggeredWhenTransition()
+							if self.fsa_selectedTransition == None and self.weaved_processing_cbd:
+								self.fsa_selectedTransition = self.weaved_triggered_when_transition
+							end
+							self.weaved_step_executed = True
+							self.weaved_processing_cbd = True
+							
+							print('Transition to ProcessingCBD')
+						}
+					OnEnter {
+						print('Performing CheckNextComponent...')
+						print('Performing CheckNextComponent... DONE')
+					}
+				State('CheckCycle'):
+					Transition(target='../CheckNextComponent'):
+						guard = {self->cbd_currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbd_cbdController->computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					Transition(target='../CheckNextComponent'):
+						guard = {not self->cbd_currentComponentIsCycle()}
+						Actions {
+							print('Transition to CheckNextComponent')
+							self.cbd_cbdController->computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+						}
+					OnEnter {
+						print('Performing CheckCycle...')
+						print('Performing CheckCycle... DONE')
+					}
+			State('CBD_SimulationComplete'):
+				Transition(target='../ProcessingCBD'):
+					guard = {self->cbd_maxIterationsReached()}
+					Actions {
+						self.weaved_step_executed = True
+						self.weaved_ended_cbd = True
+						self.weaved_processing_cbd = True
+						print('Transition to ProcessingCBD')
+					}
+			State('FSA_End')
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/fsa_cbd_simulator/weaved_cbd_fsa_simulator_normal_form.sccd

@@ -0,0 +1,394 @@
+Diagram(name = 'Weaved_CBD_FSA_Simulator_Manual',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Automatically woven CBD and FSA simulators with the FSA being the dominant.'):
+    Top {
+		import copy
+        from CBD_Controller import CBDController
+		import Options
+		from fsa_cbd_weaved_classes import CBDState
+		from weaved_cbd_fsa_lib import FSACBDLib
+    }
+
+    Class(name = 'Weaved_CBD_FSA_Simulator', default = True):
+        Attribute(name = 'fsa_timestep')
+		Attribute(name = 'fsa_elapsed')
+		Attribute(name = 'fsa_currentState')
+		Attribute(name = 'fsa_logicalTime')
+		Attribute(name = 'fsa_currentEvent')
+		Attribute(name = 'fsa_selectedTransition')
+		Attribute(name = 'fsa_eventList')
+		
+		Attribute(name='cbd_iteration')
+        Attribute(name='cbd_strongComponentList')
+        Attribute(name='cbd_currentCompIdx')
+        Attribute(name='cbd_clock')
+        Attribute(name='cbd_options')
+        Attribute(name='cbd_delta')
+        Attribute(name='cbd_controller')
+		Attribute(name='cbd_depGraph')
+		
+		Attribute(name='weaved_delta')
+        Attribute(name='woven_child_initialized')
+		Attribute(name='weaved_model')
+        Attribute(name='weaved_global_state')
+        Attribute(name='weaved_previous_global_state')
+        Attribute(name='weaved_triggered_when_transition')
+        Attribute(name='weaved_lib')
+        
+		Method fsa_processEvent(event) {
+			if (event != None):
+				self.fsa_eventList->popEvent(event)
+				event.processed = True
+			end
+		}
+		
+		Method fsa_getInputEventAt(time) {
+			return self.fsa_eventList->getInputAt(time)
+		}
+		
+		Method cbd_computeBlock(){
+			if self->cbd_currentComponentIsCycle():
+				self.cbd_controller->computeNextAlgebraicLoop(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+			else:
+				self.cbd_controller->computeNextBlock(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_iteration)
+			end
+		}
+		
+		Method cbd_maxIterationsReached() {
+			return self.cbd_iteration >= self.cbd_options->getMaxIterations()
+        }
+		
+		Method cbd_hasNextStrongComponent() {
+			return (self.cbd_currentCompIdx) < len(self.cbd_strongComponentList)
+        }
+		
+		Method cbd_currentComponentIsCycle() {
+            return self.cbd_controller->componentIsCycle(self.cbd_strongComponentList[self.cbd_currentCompIdx], self.cbd_depGraph)
+        }
+		
+		Method updateGlobalState() {
+			self.weaved_previous_global_state = copy->deepcopy(self.weaved_global_state)
+            self.weaved_lib->updateGlobalState(self.weaved_global_state, self.fsa_currentState.cbd, self.cbd_clock)
+        }
+		
+		Method updateCBDState() {
+            self.weaved_lib->updateCBDState(self.weaved_global_state, self.fsa_currentState.cbd)
+        }
+		
+		Method getTriggeredWhenTransition() {
+            return self.weaved_lib->getTriggeredWhenTransition(self.weaved_model, self.fsa_currentState, self.weaved_global_state, self.weaved_previous_global_state)
+        }
+		
+        Constructor(cbd_options, amodel, fsa_events) {
+            self.weaved_lib = FSACBDLib()
+			
+			self.cbd_options = cbd_options
+			self.cbd_delta = self.cbd_options->getDeltaT()
+			
+			self.weaved_model = amodel
+			self.fsa_eventList = fsa_events
+			self.fsa_timestep = 1.0
+        }
+		
+        StateMachine:
+            initial = 'FSA'
+			final = 'HybridTerminated'
+			State('ParentStarted'):
+				Transition(target='../FSA/Initialized'):
+					Actions {
+						print('From ParentStarted to FSA/Initialized... ')
+						self.weaved_global_state = dict()
+						self.weaved_previous_global_state = dict()
+						self.woven_child_initialized = False
+					}
+			State('FSA'):
+				initial = 'Started'
+				State('Started'):
+					Transition(target='../Initialized'):
+						guard = { False }
+						Actions {
+							print('From FSA/Started to Initialized... ')
+							self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+							self.fsa_logicalTime = 0.0
+							self.fsa_elapsed = 0
+							self.fsa_timestep = self.weaved_delta
+							self.fsa_currentState = self.weaved_model.initialState
+							
+							self.weaved_global_state = dict()
+							self.weaved_previous_global_state = dict()
+						}
+					Transition(target='../../ParentStarted'):
+						Actions {
+							print('From FSA/Started to ParentStarted... ')
+							self.weaved_delta = min(self.fsa_timestep, self.cbd_delta)
+							self.fsa_logicalTime = 0.0
+							self.fsa_elapsed = 0
+							self.fsa_timestep = self.weaved_delta
+							self.fsa_currentState = self.weaved_model.initialState
+							
+						}
+				State('Initialized'):
+					Transition(target='../MacroStepProcessed'):
+						Actions {
+							print('From FSA/Initialized to MacroStepProcessed... ')
+						}
+				State('MacroStepProcessed'):
+					Transition(target='../MacroStepPrepared'):
+						guard = { not self.fsa_currentState.final }
+						Actions {
+							print('From FSA/MacroStepProcessed to MacroStepPrepared and reading events... ')
+							self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+							self.fsa_selectedTransition = self.weaved_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+							print(self.fsa_currentEvent)
+							print(self.fsa_selectedTransition)
+						}
+					Transition(target='../Terminated'):
+						guard = { self.fsa_currentState.final }
+						Actions {
+							print('From FSA/MacroStepProcessed to Terminated... ')
+						}
+				State('MacroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						guard = { False }
+						Actions {
+							print('From FSA/MacroStepPrepared to MicroStepProcessed... ')
+						}
+					Transition(target='../../ParentPaused'):
+						Actions {
+							print('From FSA/MacroStepPrepared to ParentPaused... ')
+						}
+				State('MicroStepProcessed'):
+					Transition(target='../MacroStepProcessed'):
+						guard = { self.fsa_selectedTransition == None}
+						Actions {
+							print('From FSA/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+							self.fsa_logicalTime = self.fsa_logicalTime + self.fsa_timestep
+							self.fsa_elapsed = self.fsa_elapsed + self.fsa_timestep
+							print(self.fsa_logicalTime)
+							print(self.fsa_elapsed)
+						}
+					Transition(target='../MicroStepPrepared'):
+						guard = { self.fsa_selectedTransition != None }
+						Actions {
+							print('From FSA/MicroStepProcessed to MicroStepPrepared... ')
+						}
+				State('MicroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						guard = { False }
+						Actions {
+							print('From FSA/MicroStepPrepared to MicroStepProcessed and attempting to take transition... ')
+							print('Transition to be taken: ' + str(self.fsa_selectedTransition))
+							self.fsa_currentState = self.fsa_selectedTransition.target
+							self.fsa_elapsed = 0
+							self->fsa_processEvent(self.fsa_currentEvent)
+							self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+							self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							print('New state: ' + str(self.fsa_currentState))
+							
+							print('Reading events:')
+							self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+							self.fsa_selectedTransition = self.weaved_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+							print(self.fsa_currentEvent)
+							print(self.fsa_selectedTransition)
+						}
+					Transition(target='../../ParentMicroStepProcessed'):
+						Actions {
+							print('From FSA/MicroStepPrepared to ParentMicroStepProcessed and attempting to take transition... ')
+							print('Transition to be taken: ' + str(self.fsa_selectedTransition))
+							self.fsa_currentState = self.fsa_selectedTransition.target
+							self.fsa_elapsed = 0
+							self->fsa_processEvent(self.fsa_currentEvent)
+							self.weaved_lib->dumpDiscreteEvent(self.weaved_model, self.fsa_logicalTime, self.fsa_currentState , self.fsa_selectedTransition)
+							self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							print('New state: ' + str(self.fsa_currentState))
+							
+							print('Reading events:')
+							self.fsa_currentEvent = self->fsa_getInputEventAt(self.fsa_logicalTime)
+							self.fsa_selectedTransition = self.weaved_model->getTransitionFrom(self.fsa_currentState, self.fsa_currentEvent, self.fsa_elapsed)
+							print(self.fsa_currentEvent)
+							print(self.fsa_selectedTransition)
+						}
+				State('Terminated'):
+					Transition(target='../../HybridTerminated'):
+						Actions {
+							print('From FSA/Terminated to HybridTerminated... ')
+						}
+			State('ParentMicroStepProcessed'):
+				Transition(target='../ParentPaused'):
+					Actions {
+						print('From ParentMicroStepProcessed to ParentPaused and resetting the child... ')
+						self.woven_child_initialized = False
+					}
+			State('HybridTerminated')
+			State('ChildNotInitialized'):
+				Transition(target='../CBD/Started'):
+					Actions {
+						print('From ChildNotInitialized to CBD/Started... ')
+						self.cbd_delta = self.weaved_delta
+						self->updateCBDState()
+						self.woven_child_initialized = True
+					}
+			State('ChildInitialized'):
+				Transition(target='../CBD/MacroStepProcessed'):
+					Actions {
+						print('From ChildInitialized to CBD/MacroStepProcessed... ')
+						self.cbd_clock = self.cbd_clock + self.cbd_delta
+						self.cbd_iteration = self.cbd_iteration + 1
+						self.cbd_controller->advanceTimeStep()
+						print("CBD clock: " + str(self.cbd_clock))
+						print("CBD iteration: " + str(self.cbd_iteration))	
+					}
+			State('ChildPaused'):
+				Transition(target='../StateEventDetected'):
+					guard = { self.weaved_triggered_when_transition != None }
+					Actions {
+						print('From ChildPaused to StateEventDetected... ')
+					}
+				Transition(target='../NoStateEventDetected'):
+					guard = { self.weaved_triggered_when_transition == None }
+					Actions {
+						print('From ChildPaused to NoStateEventDetected... ')
+					}
+			State('NoStateEventDetected'):
+				Transition(target='../ChildProcessed'):
+					Actions {
+						print('From NoStateEventDetected to ChildProcessed... ')
+					}
+			State('StateEventDetected'):
+				Transition(target='../ChildProcessed'):
+					Actions {
+						print('From StateEventDetected to ChildProcessed... ')
+						if self.fsa_selectedTransition == None:
+							self.fsa_selectedTransition = self.weaved_triggered_when_transition
+						end
+					}
+			State('ChildProcessed'):
+				Transition(target='../FSA/MicroStepProcessed'):
+					Actions {
+						print('From ChildProcessed to FSA/MicroStepProcessed... ')
+					}
+			State('ParentPaused'):
+				Transition(target='../ChildProcessed'):
+					guard = { not isinstance(self.fsa_currentState, CBDState) }
+					Actions {
+						print('From ParentPaused to ChildProcessed without any child to process... ')
+					}
+				Transition(target='../ChildDetected'):
+					guard = { isinstance(self.fsa_currentState, CBDState) }
+					Actions {
+						print('From ParentPaused to ChildDetected... ')
+						self.cbd_model = self.fsa_currentState.cbd
+					}
+			State('ChildDetected'):
+				Transition(target='../ChildNotInitialized'):
+					guard = { not self.woven_child_initialized }
+					Actions {
+						print('From ChildDetected to ChildNotInitialized... ')
+					}
+				Transition(target='../ChildInitialized'):
+					guard = { self.woven_child_initialized }
+					Actions {
+						print('From ChildDetected to ChildInitialized... ')
+					}
+			State('CBD'):
+				initial = 'Started'
+				State('Started'):
+					Transition(target='../Initialized'):
+						Actions {
+							print('From CBD/Started to Initialized... ')
+							print('Performing initialization...')
+							self.cbd_iteration = 0
+							self.cbd_clock = 0
+							self.cbd_controller = CBDController(self.cbd_model,self.cbd_delta)
+							self.cbd_controller->initSimulation()
+							print('Performing initialization... DONE')
+						}
+				State('Initialized'):
+					Transition(target='../MacroStepProcessed'):
+						Actions {
+							print('From CBD/Initialized to MacroStepProcessed... ')
+						}
+				State('MacroStepProcessed'):
+					Transition(target='../MacroStepPrepared'):
+						guard = { not self->cbd_maxIterationsReached() }
+						Actions {
+							print('From CBD/MacroStepProcessed to MacroStepPrepared... ')
+							self.cbd_currentCompIdx = 0
+							self.cbd_depGraph = self.cbd_controller->createDepGraph(self.cbd_iteration)
+							self.cbd_strongComponentList = self.cbd_controller->createStrongComponents(self.cbd_depGraph, self.cbd_iteration)
+						}
+					Transition(target='../Terminated'):
+						guard = { self->cbd_maxIterationsReached() }
+						Actions {
+							print('From CBD/MacroStepProcessed to Terminated... ')
+						}
+				State('MacroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From CBD/MacroStepPrepared to MicroStepProcessed... ')
+						}
+				State('MicroStepProcessed'):
+					Transition(target='../MacroStepProcessed'):
+						guard = { not self->cbd_hasNextStrongComponent() and False }
+						Actions {
+							print('From CBD/MicroStepProcessed to MacroStepProcessed and advancing time... ')
+							self.cbd_clock = self.cbd_clock + self.cbd_delta
+							self.cbd_iteration = self.cbd_iteration + 1
+							self.cbd_controller->advanceTimeStep()
+							print("CBD clock: " + str(self.cbd_clock))
+							print("CBD iteration: " + str(self.cbd_iteration))
+						}
+					Transition(target='../../ChildPaused'):
+						guard = { not self->cbd_hasNextStrongComponent() }
+						Actions {
+							print('From CBD/MicroStepProcessed to ChildPaused and detecting triggered transitions... ')
+							self->updateGlobalState()
+							self.weaved_lib->dumpGlobalState(self.weaved_model, self.weaved_global_state , self.fsa_logicalTime, self.fsa_currentState)
+							self.weaved_triggered_when_transition = self->getTriggeredWhenTransition()
+						}
+					Transition(target='../MicroStepPrepared'):
+						guard = { self->cbd_hasNextStrongComponent() }
+						Actions {
+							print('From CBD/MicroStepProcessed to MicroStepPrepared')
+						}
+				State('MicroStepPrepared'):
+					Transition(target='../MicroStepProcessed'):
+						Actions {
+							print('From CBD/MicroStepPrepared to MicroStepProcessed...')
+							self->cbd_computeBlock()
+							self.cbd_currentCompIdx = self.cbd_currentCompIdx + 1
+						}
+				State('Terminated'):
+					Transition(target='../../HybridTerminated'):
+						Actions {
+							print('From CBD/Terminated to HybridTerminated... ')
+						}
+				
+			
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/fsa_cbd_simulator/weaved_runner.py

@@ -0,0 +1,74 @@
+'''
+Created on 10-sep.-2014
+
+@author: Bruno
+'''
+#from bokeh.plotting import figure, output_file, show
+from fsaclasses import State, Transition, After, Float, FSAModel, Event, RunTimeEvent, Events
+from fsa_cbd_weaved_classes import CBDState
+from CBDMultipleOutput.models.HarmonicOscilator import CircleCBDDerivative
+from weaved_cbd_fsa_simulator import Controller
+from Options import Options
+from models.bouncingball import BouncingBallFSA
+import os
+from weaved_cbd_fsa_lib import FSACBDLib
+
+CBD_DELTA = 0.01
+
+def buildModel():
+    statea = State("a")
+    stateb = State("b")
+    statec = CBDState("c", CircleCBDDerivative("Harmonic Oscilator", CBD_DELTA))
+    #statec = State("c")
+    stated = State("d")
+    statef = State("f", True)
+    
+    transitionab = Transition("a2b",statea,stateb)
+    transitionab.trigger = After(Float(5.0))
+    
+    transitionbc = Transition("b2c",stateb,statec)
+    transitionbc.trigger = After(Float(2.0))
+
+    transitioncd = Transition("c2d",statec,stated)
+    transitioncd.trigger = Event("c")
+
+    transitiondf = Transition("d2f",stated,statef)
+    transitiondf.trigger = After(Float(5.0))
+
+    fsamodel = FSAModel(
+                        [statea,stateb,statec,stated],
+                        [transitionab,transitionbc,transitioncd,transitiondf]
+                        )
+    fsamodel.initialState = statea
+    return fsamodel
+
+if __name__ == '__main__':
+    
+    if os.path.exists(FSACBDLib.OUTPUT_EVENTS):
+        os.remove(FSACBDLib.OUTPUT_EVENTS)
+    if os.path.exists(FSACBDLib.OUTPUT_SIGNALS):
+        os.remove(FSACBDLib.OUTPUT_SIGNALS)
+    
+    options = Options(delta = CBD_DELTA)
+    options.setMaxIterations(10000);
+    fsamodel = BouncingBallFSA()
+    events = Events([RunTimeEvent('kick',13.0), RunTimeEvent('kick',23.0), RunTimeEvent('kick',37.0) ,RunTimeEvent('enough',60.0)])
+    #events = Events([RunTimeEvent('enough',25.0)])
+    controller = Controller(options, fsamodel, events, keep_running=False)
+    controller.start()
+    controller.join()
+    
+    '''
+    cbdModel = fsamodel.states[2].cbd;
+    
+    times = []
+    values = []
+    for timeValuePair in cbdModel.getSignal("neg"):
+        times.append(timeValuePair.time)
+        values.append(timeValuePair.value)
+        
+    output_file("./plot.html", title="Plot")
+    p = figure(title="Something vs Otherthing", x_axis_label="Time", y_axis_label="Values")
+    p.line(times, values, legend="Something", line_width=1, line_color="red")
+    show(p)
+    '''

fsa_cbd_composition/fsa_fsa_simulator/.project

@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>fsa_fsa_simulator</name>
+	<comment></comment>
+	<projects>
+		<project>cbdsimulator</project>
+		<project>fsasimulator</project>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>

fsa_cbd_composition/fsa_fsa_simulator/.pydevproject

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
+<?eclipse-pydev version="1.0"?><pydev_project>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_VERSION">python 2.7</pydev_property>
+<pydev_property name="org.python.pydev.PYTHON_PROJECT_INTERPRETER">Default</pydev_property>
+<pydev_pathproperty name="org.python.pydev.PROJECT_SOURCE_PATH">
+<path>/${PROJECT_DIR_NAME}</path>
+</pydev_pathproperty>
+</pydev_project>

fsa_cbd_composition/fsa_fsa_simulator/fsa_fsa_weaved_classes.py

@@ -0,0 +1,9 @@
+from fsaclasses import State
+
+class FSAState(State):
+    def __init__(self, name, fsaModel, final = False):
+        State.__init__(self, name, final)
+        self.model = fsaModel
+        
+    def getName(self):
+        return self.name

fsa_cbd_composition/fsa_fsa_simulator/models/sample_hierarchical_fsa.py

@@ -0,0 +1,78 @@
+from fsa_fsa_weaved_classes import FSAState
+from fsaclasses import FSAModel, Transition, Event, State, After, AtomValue
+
+class SampleFSA_A(FSAModel):
+    def __init__(self):
+        x = State("x")
+        y = State("y")
+        z = State("z", final=True)
+        
+        x2y = Transition("x2y", x, y)
+        y2z = Transition("y2z", y, z)
+        
+        x2y.trigger = After(AtomValue(2.0))
+        y2z.trigger = Event("e2")
+        
+        self.states = [
+                       x,
+                       y,
+                       z
+                       ]
+        
+        self.initialState = x
+        
+        self.transitions = [
+                            x2y,
+                            y2z
+                            ]
+
+class SampleFSA_B(FSAModel):
+    def __init__(self):
+        x = State("x")
+        y = State("y")
+        z = State("z")
+        
+        x2y = Transition("x2y", x, y)
+        z2y = Transition("z2y", z, y)
+        
+        x2y.trigger = Event("e1")
+        z2y.trigger = After(AtomValue(2.0))
+        
+        self.states = [
+                       x,
+                       y,
+                       z
+                       ]
+        
+        self.initialState = x
+        
+        self.transitions = [
+                            x2y,
+                            z2y
+                            ]
+
+
+class TopLevelFSA(FSAModel):
+    def __init__(self):
+        a = FSAState("a", SampleFSA_A())
+        b = FSAState("b", SampleFSA_B())
+        c = State("c", final=True)
+        
+        a2b = Transition("a2b", a, b)
+        b2c = Transition("b2c", b, c)
+        
+        a2b.trigger = Event("e2")
+        b2c.trigger = After(AtomValue(10.0))
+        
+        self.states = [
+                       a,
+                       b,
+                       c
+                       ]
+        
+        self.initialState = a
+        
+        self.transitions = [
+                            a2b,
+                            b2c
+                            ]

fsa_cbd_composition/fsa_fsa_simulator/weaved_fsa_fsa_lib.py

@@ -0,0 +1,40 @@
+'''
+@author: Claudio Gomes, Bruno Barroca and Sadaf Mustafiz
+'''
+import numpy
+
+# These should depend on the step size.
+NUM_TOLERANCE = 1e-05
+NUM_ABS_TOLERANCE = 1e-08
+	
+class FSAFSALib():
+	
+	def __init__(self):
+		pass
+	
+	def equal(self, a, b):
+		return numpy.isclose(a, b, NUM_TOLERANCE, NUM_ABS_TOLERANCE)
+	
+	def assertion(self, condition):
+		assert condition
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+				

fsa_cbd_composition/fsa_fsa_simulator/weaved_fsa_fsa_simulator.py

@@ -0,0 +1,579 @@
+"""
+Generated by Statechart compiler by Glenn De Jonghe and Joeri Exelmans
+
+Date:   Mon Dec 07 22:42:50 2015
+
+Model author: Sadaf Mustafiz and Bruno Barroca and Claudio Gomes
+Model name:   Weaved_FSA_FSA_Simulator_Manual
+Model description:
+Manually woven FSA and FSA simulators.
+"""
+
+from python_runtime.statecharts_core import *
+from python_runtime.libs.ui import *
+from python_runtime.libs.utils import *
+from fsa_fsa_weaved_classes import FSAState
+from weaved_fsa_fsa_lib import FSAFSALib
+
+# package "Weaved_FSA_FSA_Simulator_Manual"
+
+class Weaved_FSA_FSA_Simulator(RuntimeClassBase):
+	def __init__(self, controller, amodel, events, delta):
+		RuntimeClassBase.__init__(self, controller)
+		
+		self.semantics.big_step_maximality = StatechartSemantics.TakeMany
+		self.semantics.internal_event_lifeline = StatechartSemantics.Queue
+		self.semantics.input_event_lifeline = StatechartSemantics.FirstComboStep
+		self.semantics.priority = StatechartSemantics.SourceParent
+		self.semantics.concurrency = StatechartSemantics.Single
+		
+		# User defined attributes
+		self.woven_child_initialized = None
+		self.child_currentState = None
+		self.parent_timestep = None
+		self.parent_selectedTransition = None
+		self.parent_elapsed = None
+		self.child_currentEvent = None
+		self.child_logicalTime = None
+		self.parent_eventList = None
+		self.child_elapsed = None
+		self.woven_delta = None
+		self.parent_currentState = None
+		self.child_timestep = None
+		self.parent_currentEvent = None
+		self.woven_child_processed = None
+		self.parent_logicalTime = None
+		self.child_selectedTransition = None
+		self.child_eventList = None
+		
+		# Call user defined constructor
+		Weaved_FSA_FSA_Simulator.user_defined_constructor(self, amodel, events, delta)
+	
+	def user_defined_constructor(self, amodel, events, delta):
+		self.parent_model = amodel
+		self.parent_eventList = events
+		self.woven_delta = delta
+		self.woven_lib = FSAFSALib()
+	
+	def user_defined_destructor(self):
+		pass
+	
+	
+	# User defined method
+	def parent_processEvent(self, event):
+		if (event != None):
+			self.parent_eventList.popEvent(event)
+			event.processed = True
+	
+	
+	# User defined method
+	def child_getInputEventAt(self, time):
+		return self.child_eventList.getInputAt(time)
+	
+	
+	# User defined method
+	def child_processEvent(self, event):
+		if (event != None):
+			self.child_eventList.popEvent(event)
+			event.processed = True
+	
+	
+	# User defined method
+	def assertion(self, condition):
+		self.woven_lib.assertion(condition)
+	
+	
+	# User defined method
+	def lessThan(self, a, b):
+		return a < b and not self.woven_lib.equal(a, b)
+	
+	
+	# User defined method
+	def parent_getInputEventAt(self, time):
+		return self.parent_eventList.getInputAt(time)
+	
+	def initializeStatechart(self):
+		self.current_state[self.Root] = []
+		self.current_state[self.Root_Child_FSA] = []
+		self.current_state[self.Root_Parent_FSA] = []
+		
+		# Enter default state
+		self.enter_Root_Start_Woven()
+	
+	# Unique IDs for all statechart nodes
+	Root = 0
+	Root_Child_FSA = 1
+	Root_Parent_FSA = 2
+	Root_ProcessChild = 3
+	Root_Start_Woven = 4
+	Root_Child_FSA_FSA_Start = 5
+	Root_Child_FSA_FSA_Processing = 6
+	Root_Child_FSA_FSA_Check = 7
+	Root_Parent_FSA_FSA_Start = 8
+	Root_Parent_FSA_FSA_End = 9
+	Root_Parent_FSA_FSA_Check = 10
+	Root_Parent_FSA_FSA_Processing = 11
+	
+	# Statechart enter/exit action method(s)
+	
+	def enter_Root_Child_FSA(self):
+		self.current_state[self.Root].append(self.Root_Child_FSA)
+	
+	def exit_Root_Child_FSA(self):
+		if self.Root_Child_FSA_FSA_Start in self.current_state[self.Root_Child_FSA]:
+			self.exit_Root_Child_FSA_FSA_Start()
+		if self.Root_Child_FSA_FSA_Processing in self.current_state[self.Root_Child_FSA]:
+			self.exit_Root_Child_FSA_FSA_Processing()
+		if self.Root_Child_FSA_FSA_Check in self.current_state[self.Root_Child_FSA]:
+			self.exit_Root_Child_FSA_FSA_Check()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_Parent_FSA(self):
+		self.current_state[self.Root].append(self.Root_Parent_FSA)
+	
+	def exit_Root_Parent_FSA(self):
+		if self.Root_Parent_FSA_FSA_Start in self.current_state[self.Root_Parent_FSA]:
+			self.exit_Root_Parent_FSA_FSA_Start()
+		if self.Root_Parent_FSA_FSA_End in self.current_state[self.Root_Parent_FSA]:
+			self.exit_Root_Parent_FSA_FSA_End()
+		if self.Root_Parent_FSA_FSA_Check in self.current_state[self.Root_Parent_FSA]:
+			self.exit_Root_Parent_FSA_FSA_Check()
+		if self.Root_Parent_FSA_FSA_Processing in self.current_state[self.Root_Parent_FSA]:
+			self.exit_Root_Parent_FSA_FSA_Processing()
+		self.current_state[self.Root] = []
+	
+	def enter_Root_ProcessChild(self):
+		self.current_state[self.Root].append(self.Root_ProcessChild)
+	
+	def exit_Root_ProcessChild(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_Start_Woven(self):
+		self.current_state[self.Root].append(self.Root_Start_Woven)
+	
+	def exit_Root_Start_Woven(self):
+		self.current_state[self.Root] = []
+	
+	def enter_Root_Child_FSA_FSA_Start(self):
+		self.current_state[self.Root_Child_FSA].append(self.Root_Child_FSA_FSA_Start)
+	
+	def exit_Root_Child_FSA_FSA_Start(self):
+		self.current_state[self.Root_Child_FSA] = []
+	
+	def enter_Root_Child_FSA_FSA_Processing(self):
+		self.current_state[self.Root_Child_FSA].append(self.Root_Child_FSA_FSA_Processing)
+	
+	def exit_Root_Child_FSA_FSA_Processing(self):
+		self.current_state[self.Root_Child_FSA] = []
+	
+	def enter_Root_Child_FSA_FSA_Check(self):
+		print('Attempting to read event: ')
+		self.child_currentEvent = self.child_getInputEventAt(self.child_logicalTime)
+		self.child_selectedTransition = self.child_model.getTransitionFrom(self.child_currentState, self.child_currentEvent, self.child_elapsed)
+		print('Read event: ' + str(self.child_currentEvent))
+		print('Selected transition: ' + str(self.child_selectedTransition))
+		self.current_state[self.Root_Child_FSA].append(self.Root_Child_FSA_FSA_Check)
+	
+	def exit_Root_Child_FSA_FSA_Check(self):
+		self.current_state[self.Root_Child_FSA] = []
+	
+	def enter_Root_Parent_FSA_FSA_Start(self):
+		self.current_state[self.Root_Parent_FSA].append(self.Root_Parent_FSA_FSA_Start)
+	
+	def exit_Root_Parent_FSA_FSA_Start(self):
+		self.current_state[self.Root_Parent_FSA] = []
+	
+	def enter_Root_Parent_FSA_FSA_End(self):
+		self.current_state[self.Root_Parent_FSA].append(self.Root_Parent_FSA_FSA_End)
+	
+	def exit_Root_Parent_FSA_FSA_End(self):
+		self.current_state[self.Root_Parent_FSA] = []
+	
+	def enter_Root_Parent_FSA_FSA_Check(self):
+		print('Attempting to read event: ')
+		self.parent_currentEvent = self.parent_getInputEventAt(self.parent_logicalTime)
+		self.parent_selectedTransition = self.parent_model.getTransitionFrom(self.parent_currentState, self.parent_currentEvent, self.parent_elapsed)
+		print('Read event: ' + str(self.parent_currentEvent))
+		print('Selected transition: ' + str(self.parent_selectedTransition))
+		self.current_state[self.Root_Parent_FSA].append(self.Root_Parent_FSA_FSA_Check)
+	
+	def exit_Root_Parent_FSA_FSA_Check(self):
+		self.current_state[self.Root_Parent_FSA] = []
+	
+	def enter_Root_Parent_FSA_FSA_Processing(self):
+		self.current_state[self.Root_Parent_FSA].append(self.Root_Parent_FSA_FSA_Processing)
+	
+	def exit_Root_Parent_FSA_FSA_Processing(self):
+		self.current_state[self.Root_Parent_FSA] = []
+	
+	# Statechart enter/exit default method(s)
+	
+	def enterDefault_Root_Child_FSA(self):
+		self.enter_Root_Child_FSA()
+		self.enter_Root_Child_FSA_FSA_Start()
+	
+	def enterDefault_Root_Parent_FSA(self):
+		self.enter_Root_Parent_FSA()
+		self.enter_Root_Parent_FSA_FSA_Start()
+	
+	# Statechart transitions
+	
+	def generateCandidatesChildren_Root(self):
+		if self.current_state[self.Root][0] == self.Root_ProcessChild:
+			return self.generateCandidates_Root_ProcessChild()
+		elif self.current_state[self.Root][0] == self.Root_Start_Woven:
+			return self.generateCandidates_Root_Start_Woven()
+		elif self.current_state[self.Root][0] == self.Root_Child_FSA:
+			return self.generateCandidates_Root_Child_FSA()
+		elif self.current_state[self.Root][0] == self.Root_Parent_FSA:
+			return self.generateCandidates_Root_Parent_FSA()
+		return False
+	
+	def generateCandidates_Root(self):
+		if not self.combo_step.isArenaChanged(self.Root):
+			return self.generateCandidatesChildren_Root()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_ProcessChild(self):
+		enabled_events = self.getEnabledEvents()
+		if self.woven_child_processed[self.parent_currentState.name] and self.lessThan(self.child_logicalTime, self.parent_logicalTime) or (self.child_selectedTransition != None and self.parent_selectedTransition == None):
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition == None and self.parent_selectedTransition != None and self.parent_logicalTime == self.child_logicalTime:
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_2, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition == None and self.parent_selectedTransition == None and self.parent_logicalTime == self.child_logicalTime:
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_3, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.woven_child_initialized[self.parent_currentState.name] and not self.woven_child_processed[self.parent_currentState.name]:
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_4, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if not self.woven_child_initialized[self.parent_currentState.name] and not self.woven_child_processed[self.parent_currentState.name]:
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_5, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition != None and self.parent_selectedTransition != None:
+			self.small_step.addCandidate(self.transition_Root_ProcessChild_6, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_ProcessChild(self):
+		if not self.combo_step.isArenaChanged(self.Root_ProcessChild):
+			return self.generateCandidatesCurrent_Root_ProcessChild()
+		else:
+			return True
+	
+	def transition_Root_ProcessChild_1(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Child_FSA/FSA_Check via already processed with unsynched time or child transition only.')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Child_FSA()
+		self.enter_Root_Child_FSA_FSA_Processing()
+	
+	def transition_Root_ProcessChild_2(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Parent_FSA/FSA_Processing via only parent selected transitions and time synchronized.')
+		self.woven_child_initialized[self.parent_selectedTransition.target.name] = False
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Parent_FSA()
+		self.enter_Root_Parent_FSA_FSA_Processing()
+	
+	def transition_Root_ProcessChild_3(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Parent_FSA/FSA_Processing via no selected transitions and time synchronized.')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Parent_FSA()
+		self.enter_Root_Parent_FSA_FSA_Processing()
+	
+	def transition_Root_ProcessChild_4(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Child_FSA/FSA_Check via already initialized.')
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Child_FSA()
+		self.enter_Root_Child_FSA_FSA_Check()
+	
+	def transition_Root_ProcessChild_5(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Child_FSA/FSA_Check via not initialized.')
+		self.woven_child_initialized[self.parent_currentState.name] = True
+		self.child_model = self.parent_currentState.model
+		self.child_eventList = self.parent_eventList
+		self.child_logicalTime = self.parent_logicalTime
+		self.child_elapsed = 0.0
+		self.child_timestep = self.woven_delta
+		self.child_currentState = self.child_model.initialState
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Child_FSA()
+		self.enter_Root_Child_FSA_FSA_Check()
+	
+	def transition_Root_ProcessChild_6(self, parameters):
+		self.exit_Root_ProcessChild()
+		print('Going to Parent_FSA/FSA_Processing via conflict resolution.')
+		self.woven_child_initialized[self.parent_selectedTransition.target.name] = False
+		self.child_selectedTransition = None
+		self.assertion(self.woven_lib.equal(self.parent_logicalTime, self.child_logicalTime))
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_Parent_FSA()
+		self.enter_Root_Parent_FSA_FSA_Processing()
+	
+	def generateCandidatesCurrent_Root_Start_Woven(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Start_Woven_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Start_Woven(self):
+		if not self.combo_step.isArenaChanged(self.Root_Start_Woven):
+			return self.generateCandidatesCurrent_Root_Start_Woven()
+		else:
+			return True
+	
+	def transition_Root_Start_Woven_1(self, parameters):
+		self.exit_Root_Start_Woven()
+		self.woven_child_processed = dict()
+		self.woven_child_initialized = dict()
+		self.combo_step.setArenaChanged(self.Root)
+		self.enterDefault_Root_Parent_FSA()
+	
+	def generateCandidatesChildren_Root_Child_FSA(self):
+		if self.current_state[self.Root_Child_FSA][0] == self.Root_Child_FSA_FSA_Start:
+			return self.generateCandidates_Root_Child_FSA_FSA_Start()
+		elif self.current_state[self.Root_Child_FSA][0] == self.Root_Child_FSA_FSA_Processing:
+			return self.generateCandidates_Root_Child_FSA_FSA_Processing()
+		elif self.current_state[self.Root_Child_FSA][0] == self.Root_Child_FSA_FSA_Check:
+			return self.generateCandidates_Root_Child_FSA_FSA_Check()
+		return False
+	
+	def generateCandidates_Root_Child_FSA(self):
+		if not self.combo_step.isArenaChanged(self.Root_Child_FSA):
+			return self.generateCandidatesChildren_Root_Child_FSA()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_Child_FSA_FSA_Start(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Child_FSA_FSA_Start_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Child_FSA_FSA_Start(self):
+		if not self.combo_step.isArenaChanged(self.Root_Child_FSA_FSA_Start):
+			return self.generateCandidatesCurrent_Root_Child_FSA_FSA_Start()
+		else:
+			return True
+	
+	def transition_Root_Child_FSA_FSA_Start_1(self, parameters):
+		self.exit_Root_Child_FSA_FSA_Start()
+		self.child_logicalTime = 0.0
+		self.child_elapsed = 0
+		self.child_timestep = self.woven_delta
+		self.child_currentState = self.child_model.initialState
+		self.combo_step.setArenaChanged(self.Root_Child_FSA)
+		self.enter_Root_Child_FSA_FSA_Check()
+	
+	def generateCandidatesCurrent_Root_Child_FSA_FSA_Processing(self):
+		enabled_events = self.getEnabledEvents()
+		if self.child_selectedTransition == None:
+			self.small_step.addCandidate(self.transition_Root_Child_FSA_FSA_Processing_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.child_selectedTransition != None and (self.child_currentEvent == None or self.child_currentEvent.processed):
+			self.small_step.addCandidate(self.transition_Root_Child_FSA_FSA_Processing_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_Child_FSA_FSA_Processing(self):
+		if not self.combo_step.isArenaChanged(self.Root_Child_FSA_FSA_Processing):
+			return self.generateCandidatesCurrent_Root_Child_FSA_FSA_Processing()
+		else:
+			return True
+	
+	def transition_Root_Child_FSA_FSA_Processing_1(self, parameters):
+		self.exit_Root_Child_FSA_FSA_Processing()
+		print('Going to FSA_Check with no transition to be done... ')
+		self.child_logicalTime = self.child_logicalTime + self.child_timestep
+		self.child_elapsed = self.child_elapsed + self.child_timestep
+		print(self.child_logicalTime)
+		print(self.child_elapsed)
+		self.combo_step.setArenaChanged(self.Root_Child_FSA)
+		self.enter_Root_Child_FSA_FSA_Check()
+	
+	def transition_Root_Child_FSA_FSA_Processing_2(self, parameters):
+		self.exit_Root_Child_FSA_FSA_Processing()
+		print('Going to FSA_Check with transition to be done... ')
+		self.child_currentState = self.child_selectedTransition.target
+		self.child_elapsed = 0
+		self.child_processEvent(self.parent_currentEvent)
+		print('changing to state: ')
+		print(self.child_currentState.getName())
+		print(self.child_logicalTime)
+		print(self.child_elapsed)
+		self.combo_step.setArenaChanged(self.Root_Child_FSA)
+		self.enter_Root_Child_FSA_FSA_Check()
+	
+	def generateCandidatesCurrent_Root_Child_FSA_FSA_Check(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Child_FSA_FSA_Check_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Child_FSA_FSA_Check(self):
+		if not self.combo_step.isArenaChanged(self.Root_Child_FSA_FSA_Check):
+			return self.generateCandidatesCurrent_Root_Child_FSA_FSA_Check()
+		else:
+			return True
+	
+	def transition_Root_Child_FSA_FSA_Check_1(self, parameters):
+		self.exit_Root_Child_FSA()
+		print('going to ProcessChild... ')
+		self.woven_child_processed[self.parent_currentState.name] = True
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ProcessChild()
+	
+	def generateCandidatesChildren_Root_Parent_FSA(self):
+		if self.current_state[self.Root_Parent_FSA][0] == self.Root_Parent_FSA_FSA_Start:
+			return self.generateCandidates_Root_Parent_FSA_FSA_Start()
+		elif self.current_state[self.Root_Parent_FSA][0] == self.Root_Parent_FSA_FSA_End:
+			return self.generateCandidates_Root_Parent_FSA_FSA_End()
+		elif self.current_state[self.Root_Parent_FSA][0] == self.Root_Parent_FSA_FSA_Check:
+			return self.generateCandidates_Root_Parent_FSA_FSA_Check()
+		elif self.current_state[self.Root_Parent_FSA][0] == self.Root_Parent_FSA_FSA_Processing:
+			return self.generateCandidates_Root_Parent_FSA_FSA_Processing()
+		return False
+	
+	def generateCandidates_Root_Parent_FSA(self):
+		if not self.combo_step.isArenaChanged(self.Root_Parent_FSA):
+			return self.generateCandidatesChildren_Root_Parent_FSA()
+		else:
+			return True
+	
+	def generateCandidatesCurrent_Root_Parent_FSA_FSA_Start(self):
+		enabled_events = self.getEnabledEvents()
+		self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Start_1, [])
+		return True
+		return False
+	
+	def generateCandidates_Root_Parent_FSA_FSA_Start(self):
+		if not self.combo_step.isArenaChanged(self.Root_Parent_FSA_FSA_Start):
+			return self.generateCandidatesCurrent_Root_Parent_FSA_FSA_Start()
+		else:
+			return True
+	
+	def transition_Root_Parent_FSA_FSA_Start_1(self, parameters):
+		self.exit_Root_Parent_FSA_FSA_Start()
+		self.parent_logicalTime = 0.0
+		self.parent_elapsed = 0
+		self.parent_currentState = self.parent_model.initialState
+		self.parent_timestep = self.woven_delta
+		self.woven_child_initialized[self.parent_currentState.name] = False
+		self.combo_step.setArenaChanged(self.Root_Parent_FSA)
+		self.enter_Root_Parent_FSA_FSA_Check()
+	
+	def generateCandidates_Root_Parent_FSA_FSA_End(self):
+		return False
+	
+	def generateCandidatesCurrent_Root_Parent_FSA_FSA_Check(self):
+		enabled_events = self.getEnabledEvents()
+		if self.parent_currentState.final == False and not isinstance(self.parent_currentState, FSAState):
+			self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Check_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.parent_currentState.final == False and isinstance(self.parent_currentState, FSAState):
+			self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Check_2, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.parent_currentState.final == True:
+			self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Check_3, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_Parent_FSA_FSA_Check(self):
+		if not self.combo_step.isArenaChanged(self.Root_Parent_FSA_FSA_Check):
+			return self.generateCandidatesCurrent_Root_Parent_FSA_FSA_Check()
+		else:
+			return True
+	
+	def transition_Root_Parent_FSA_FSA_Check_1(self, parameters):
+		self.exit_Root_Parent_FSA_FSA_Check()
+		print('Going to fsa process... ')
+		self.combo_step.setArenaChanged(self.Root_Parent_FSA)
+		self.enter_Root_Parent_FSA_FSA_Processing()
+	
+	def transition_Root_Parent_FSA_FSA_Check_2(self, parameters):
+		self.exit_Root_Parent_FSA()
+		print('Going to ProcessChild... ')
+		self.woven_child_processed[self.parent_currentState.name] = False
+		self.combo_step.setArenaChanged(self.Root)
+		self.enter_Root_ProcessChild()
+	
+	def transition_Root_Parent_FSA_FSA_Check_3(self, parameters):
+		self.exit_Root_Parent_FSA_FSA_Check()
+		print('going to end... ')
+		self.combo_step.setArenaChanged(self.Root_Parent_FSA)
+		self.enter_Root_Parent_FSA_FSA_End()
+	
+	def generateCandidatesCurrent_Root_Parent_FSA_FSA_Processing(self):
+		enabled_events = self.getEnabledEvents()
+		if self.parent_selectedTransition != None and (self.parent_currentEvent == None or self.parent_currentEvent.processed):
+			self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Processing_1, [])
+			return True
+		enabled_events = self.getEnabledEvents()
+		if self.parent_selectedTransition == None:
+			self.small_step.addCandidate(self.transition_Root_Parent_FSA_FSA_Processing_2, [])
+			return True
+		return False
+	
+	def generateCandidates_Root_Parent_FSA_FSA_Processing(self):
+		if not self.combo_step.isArenaChanged(self.Root_Parent_FSA_FSA_Processing):
+			return self.generateCandidatesCurrent_Root_Parent_FSA_FSA_Processing()
+		else:
+			return True
+	
+	def transition_Root_Parent_FSA_FSA_Processing_1(self, parameters):
+		self.exit_Root_Parent_FSA_FSA_Processing()
+		print('Going to FSA_Check with transition to be done... ')
+		self.parent_currentState = self.parent_selectedTransition.target
+		self.parent_elapsed = 0
+		self.parent_processEvent(self.parent_currentEvent)
+		self.woven_child_initialized[self.parent_currentState.name] = False
+		print('changing to state: ')
+		print(self.parent_currentState.getName())
+		print(self.parent_logicalTime)
+		print(self.parent_elapsed)
+		self.combo_step.setArenaChanged(self.Root_Parent_FSA)
+		self.enter_Root_Parent_FSA_FSA_Check()
+	
+	def transition_Root_Parent_FSA_FSA_Processing_2(self, parameters):
+		self.exit_Root_Parent_FSA_FSA_Processing()
+		print('Going to FSA_Check with no transition to be done... ')
+		self.parent_logicalTime = self.parent_logicalTime + self.parent_timestep
+		self.parent_elapsed = self.parent_elapsed + self.parent_timestep
+		print(self.parent_logicalTime)
+		print(self.parent_elapsed)
+		self.combo_step.setArenaChanged(self.Root_Parent_FSA)
+		self.enter_Root_Parent_FSA_FSA_Check()
+	
+	# Generate transition candidates for current small step
+	def generateCandidates(self):
+		self.generateCandidates_Root()
+
+class ObjectManager(ObjectManagerBase):
+	def __init__(self, controller):
+		ObjectManagerBase.__init__(self, controller)
+	
+	def instantiate(self, class_name, construct_params):
+		if class_name == "Weaved_FSA_FSA_Simulator":
+			instance = Weaved_FSA_FSA_Simulator(self.controller, construct_params[0], construct_params[1], construct_params[2])
+			instance.associations = {}
+		return instance
+
+class Controller(ThreadsControllerBase):
+	def __init__(self, amodel, events, delta, keep_running = None):
+		if keep_running == None: keep_running = True
+		ThreadsControllerBase.__init__(self, ObjectManager(self), keep_running)
+		self.object_manager.createInstance("Weaved_FSA_FSA_Simulator", [amodel, events, delta])

fsa_cbd_composition/fsa_fsa_simulator/weaved_fsa_fsa_simulator.sccd

@@ -0,0 +1,264 @@
+Diagram(name = 'Weaved_FSA_FSA_Simulator_Manual',
+        author = 'Sadaf Mustafiz and Bruno Barroca and Claudio Gomes',
+        description = 'Manually woven FSA and FSA simulators.'):
+    Top {
+		from fsa_fsa_weaved_classes import FSAState
+		from weaved_fsa_fsa_lib import FSAFSALib
+    }
+
+    Class(name = 'Weaved_FSA_FSA_Simulator', default = True):
+        
+		Attribute(name = 'parent_timestep')
+		Attribute(name = 'parent_elapsed')
+		Attribute(name = 'parent_currentState')
+		Attribute(name = 'parent_logicalTime')
+		Attribute(name = 'parent_currentEvent')
+		Attribute(name = 'parent_selectedTransition')
+		Attribute(name = 'parent_eventList')
+		
+		Attribute(name = 'child_timestep')
+		Attribute(name = 'child_elapsed')
+		Attribute(name = 'child_currentState')
+		Attribute(name = 'child_logicalTime')
+		Attribute(name = 'child_currentEvent')
+		Attribute(name = 'child_selectedTransition')
+		Attribute(name = 'child_eventList')
+		
+		Attribute(name = 'woven_child_processed')
+		Attribute(name = 'woven_child_initialized')
+		Attribute(name = 'woven_delta')
+		
+		Method parent_getInputEventAt(time) {
+			return self.parent_eventList->getInputAt(time)
+		}
+		
+		Method parent_processEvent(event) {
+			if (event != None):
+				self.parent_eventList->popEvent(event)
+				event.processed = True
+			end
+		}
+		
+		Method child_getInputEventAt(time) {
+			return self.child_eventList->getInputAt(time)
+		}
+		
+		Method child_processEvent(event) {
+			if (event != None):
+				self.child_eventList->popEvent(event)
+				event.processed = True
+			end
+		}
+		
+		Method assertion(condition) {
+			self.woven_lib->assertion(condition)
+		}
+		
+		Method lessThan(a,b){
+			return a < b and not self.woven_lib->equal(a,b)
+		}
+		
+        Constructor(amodel, events, delta) {
+			self.parent_model = amodel
+			self.parent_eventList = events
+			self.woven_delta = delta
+			self.woven_lib = FSAFSALib()
+			
+        }
+		
+        StateMachine:
+			initial = 'Start_Woven'
+			State('Start_Woven'):
+				Transition(target='../Parent_FSA'):
+					Actions {
+						self.woven_child_processed = dict()
+						self.woven_child_initialized = dict()
+					}
+            State('Parent_FSA'):
+				initial = 'FSA_Start'
+				final = 'FSA_End'
+				State('FSA_Start'):
+					Transition(target='../FSA_Check'):
+						Actions {
+							self.parent_logicalTime = 0.0
+							self.parent_elapsed = 0
+							self.parent_currentState = self.parent_model.initialState
+							self.parent_timestep = self.woven_delta
+							self.woven_child_initialized[self.parent_currentState.name] = False
+						}
+				State('FSA_Check'):
+					Transition(target='../FSA_Processing'):
+						guard = { self.parent_currentState.final == False and not isinstance(self.parent_currentState, FSAState)}
+						Actions {
+							print('Going to fsa process... ')
+						}
+					Transition(target='../FSA_End'):
+						guard = { self.parent_currentState.final == True }
+						Actions {
+							print('going to end... ')
+						}
+					Transition(target='../../ProcessChild'):
+						guard = { self.parent_currentState.final == False and isinstance(self.parent_currentState, FSAState) }
+						Actions {
+							print('Going to ProcessChild... ')
+							self.woven_child_processed[self.parent_currentState.name] = False
+						}
+					OnEnter {
+						print("Attempting to read event: ")
+						self.parent_currentEvent = self->parent_getInputEventAt(self.parent_logicalTime)
+						self.parent_selectedTransition = self.parent_model->getTransitionFrom(self.parent_currentState, self.parent_currentEvent, self.parent_elapsed)
+						
+						print("Read event: " + str(self.parent_currentEvent))
+						print("Selected transition: " + str(self.parent_selectedTransition))
+					}
+				State('FSA_Processing'):
+					Transition(target='../FSA_Check'):
+						guard = {self.parent_selectedTransition != None and (self.parent_currentEvent==None or self.parent_currentEvent.processed)}
+						Actions {
+							print('Going to FSA_Check with transition to be done... ')
+							self.parent_currentState = self.parent_selectedTransition.target
+							self.parent_elapsed = 0
+							
+							self->parent_processEvent(self.parent_currentEvent)
+							
+							self.woven_child_initialized[self.parent_currentState.name] = False
+							
+							print("changing to state: ")
+							print(self.parent_currentState->getName())
+							print(self.parent_logicalTime)
+							print(self.parent_elapsed)
+						}
+					Transition(target='../FSA_Check'):
+						guard = {self.parent_selectedTransition == None}
+						Actions {
+							print('Going to FSA_Check with no transition to be done... ')
+							
+							self.parent_logicalTime = self.parent_logicalTime + self.parent_timestep
+							self.parent_elapsed = self.parent_elapsed + self.parent_timestep
+							print(self.parent_logicalTime)
+							print(self.parent_elapsed)
+						}
+				State('FSA_End')
+			State('ProcessChild'):
+				Transition(target='../Parent_FSA/FSA_Processing'):
+					guard = { self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition==None and self.parent_selectedTransition==None and self.parent_logicalTime==self.child_logicalTime}
+					Actions {
+						print('Going to Parent_FSA/FSA_Processing via no selected transitions and time synchronized.')
+					}
+				Transition(target='../Parent_FSA/FSA_Processing'):
+					guard = { self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition==None and self.parent_selectedTransition!=None and self.parent_logicalTime==self.child_logicalTime}
+					Actions {
+						print('Going to Parent_FSA/FSA_Processing via only parent selected transitions and time synchronized.')
+						self.woven_child_initialized[self.parent_selectedTransition.target.name] = False
+					}
+				Transition(target='../Parent_FSA/FSA_Processing'):
+					guard = { self.woven_child_processed[self.parent_currentState.name] and self.child_selectedTransition!=None and self.parent_selectedTransition!=None}
+					Actions {
+						print('Going to Parent_FSA/FSA_Processing via conflict resolution.')
+						self.woven_child_initialized[self.parent_selectedTransition.target.name] = False
+						self.child_selectedTransition = None
+						self->assertion(self.woven_lib->equal(self.parent_logicalTime,self.child_logicalTime))
+					}
+				Transition(target='../Child_FSA/FSA_Check'):
+					guard = { self.woven_child_initialized[self.parent_currentState.name] and not self.woven_child_processed[self.parent_currentState.name] }
+					Actions {
+						print('Going to Child_FSA/FSA_Check via already initialized.')
+						
+					}
+				Transition(target='../Child_FSA/FSA_Check'):
+					guard = { not self.woven_child_initialized[self.parent_currentState.name] and not self.woven_child_processed[self.parent_currentState.name] }
+					Actions {
+						print('Going to Child_FSA/FSA_Check via not initialized.')
+						
+						self.woven_child_initialized[self.parent_currentState.name] = True
+						
+						self.child_model = self.parent_currentState.model
+						self.child_eventList = self.parent_eventList
+						
+						self.child_logicalTime = self.parent_logicalTime
+						self.child_elapsed = 0.0
+						self.child_timestep = self.woven_delta
+						self.child_currentState = self.child_model.initialState
+					}
+				Transition(target='../Child_FSA/FSA_Processing'):
+					guard = { self.woven_child_processed[self.parent_currentState.name] and self->lessThan(self.child_logicalTime,self.parent_logicalTime) or (self.child_selectedTransition!=None and self.parent_selectedTransition==None) }
+					Actions {
+						print('Going to Child_FSA/FSA_Check via already processed with unsynched time or child transition only.')
+					}
+			State('Child_FSA'):
+				initial = 'FSA_Start'
+				final = 'FSA_End'
+				State('FSA_Start'):
+					Transition(target='../FSA_Check'):
+						Actions {
+							self.child_logicalTime = 0.0
+							self.child_elapsed = 0
+							self.child_timestep = self.woven_delta
+							self.child_currentState = self.child_model.initialState
+						}
+				State('FSA_Check'):
+					Transition(target='../../ProcessChild'):
+						Actions {
+							print('going to ProcessChild... ')
+							self.woven_child_processed[self.parent_currentState.name] = True
+						}
+					OnEnter {
+						print("Attempting to read event: ")
+						self.child_currentEvent = self->child_getInputEventAt(self.child_logicalTime)
+						self.child_selectedTransition = self.child_model->getTransitionFrom(self.child_currentState, self.child_currentEvent, self.child_elapsed)
+						
+						print("Read event: " + str(self.child_currentEvent))
+						print("Selected transition: " + str(self.child_selectedTransition))
+					}
+				State('FSA_Processing'):
+					Transition(target='../FSA_Check'):
+						guard = {self.child_selectedTransition != None and (self.child_currentEvent==None or self.child_currentEvent.processed)}
+						Actions {
+							print('Going to FSA_Check with transition to be done... ')
+							self.child_currentState = self.child_selectedTransition.target
+							self.child_elapsed = 0
+							
+							self->child_processEvent(self.parent_currentEvent)
+							
+							print("changing to state: ")
+							print(self.child_currentState->getName())
+							print(self.child_logicalTime)
+							print(self.child_elapsed)
+						}
+					Transition(target='../FSA_Check'):
+						guard = {self.child_selectedTransition == None}
+						Actions {
+							print('Going to FSA_Check with no transition to be done... ')
+							self.child_logicalTime = self.child_logicalTime + self.child_timestep
+							self.child_elapsed = self.child_elapsed + self.child_timestep
+							print(self.child_logicalTime)
+							print(self.child_elapsed)
+						}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

fsa_cbd_composition/fsa_fsa_simulator/woven_runner.py

@@ -0,0 +1,18 @@
+'''
+@author: Claudio Gomes, Sadaf Mustafiz and Bruno Barroca
+'''
+
+import os
+from models.sample_hierarchical_fsa import TopLevelFSA
+from fsaclasses import Events, RunTimeEvent
+from weaved_fsa_fsa_simulator import Controller
+
+DELTA = 1.0
+
+if __name__ == '__main__':
+    fsaModel = TopLevelFSA()
+    events = Events([RunTimeEvent('e2',3.0), RunTimeEvent('e1',4.0)])
+    controller = Controller(fsaModel, events, DELTA, keep_running=False)
+    controller.start()
+    controller.join()
+    

fsa_cbd_composition/fsasimulator/.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>fsasimulator</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.python.pydev.PyDevBuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.python.pydev.pythonNature</nature>
+	</natures>
+</projectDescription>